home *** CD-ROM | disk | FTP | other *** search
/ Software of the Month Club 1996 September / Software of the Month Club 1996 September.iso / mac / Software Research Institute-SRI / Business / Alpha ƒ / Tcl / SystemCode / latexMacros.tcl < prev    next >
Encoding:
Text File  |  1995-12-21  |  88.6 KB  |  3,074 lines  |  [TEXT/ALFA]
  1. #############################################################################
  2. #############################################################################
  3. #
  4. # latexMacros.tcl (called from latex.tcl)
  5. #
  6. #############################################################################
  7. #
  8. # Author:  Tom Scavo <trscavo@syr.edu>
  9. #
  10. #############################################################################
  11. #############################################################################
  12.  
  13. #############################################################################
  14. # 
  15. # Basic Commands
  16. #
  17. #############################################################################
  18.  
  19. proc typesetWindow {} {
  20.     global PREFS
  21.     
  22.     # Initialization:
  23.     foreach flag {isOzTeX isTextures isCMacTeX isDirectTeX isDirectTeXPro} {
  24.         set $flag 0
  25.     }
  26.     set currentWin [lindex [winNames -f] 0]
  27.     set currentDir [file dirname $currentWin]
  28.     set currentDoc [file tail $currentWin]
  29.     set docBasename [file rootname $currentDoc]
  30.     set docExtension [file extension $currentDoc]
  31.     
  32.     # Is the window untitled or dirty?
  33.     if {[string match $currentWin $currentDoc]} {
  34.         case [askyesno -c "Save \"$currentDoc\"?"] in {
  35.             "yes" {
  36.                 if {[catch {set currentWin [saveAs "Untitled\.tex"]}]} then {return}
  37.             }
  38.             "no" {
  39.                 if {[regexp {<(.*)>} $currentDoc dummy num]} {
  40.                     set tmpFilename "Untitled$num\.tex"
  41.                 } else {
  42.                     set tmpFilename "Untitled\.tex"
  43.                 }
  44.                 set text [getText 0 [maxPos]]
  45.                 set newDoc "$PREFS:$tmpFilename"
  46.                 message "Saving $newDoc..."
  47.                 set fd [open $newDoc "w"]
  48.                 puts $fd $text
  49.                 close $fd
  50.                 set currentWin $newDoc
  51.             }
  52.             "cancel" {return}
  53.         }
  54.     } elseif {[winDirty]} {
  55.         case [askyesno -c "Save \"$currentDoc\"?"] in {
  56.             "yes" {save}
  57.             "no" {
  58.                 set text [getText 0 [maxPos]]
  59.                 set newDoc "$PREFS:temp-$currentDoc"
  60.                 message "Saving $newDoc..."
  61.                 set fd [open $newDoc "w"]
  62.                 puts $fd $text
  63.                 close $fd
  64.                 set currentWin $newDoc
  65.             }
  66.             "cancel" {return}
  67.         }
  68.     }
  69.     typeset $currentWin
  70. }
  71.  
  72. # proc typesetSelection {} {
  73. #     global PREFS
  74. #     if { [isSelection] } then { 
  75. #         set pos1 [getPos]
  76. #         if { [isInDocument] } then {
  77. #             exchangePointAndMark
  78. #             set pos2 [getPos]
  79. #             if { [isInDocument] } then {
  80. #                 set body "\r[getText $pos1 $pos2]\r"
  81. #                 set pattern {(\\documentclass.*)\\begin\{document\}}
  82. #                 set searchText [getText 0 [maxPos]]
  83. #                 if {![regexp $pattern $searchText dummy preamble]} then {return}
  84. #                 append text $preamble [buildEnvironment "document" "" $body "\r"]
  85. #                 select $pos1 $pos2
  86. #                 set newDoc "$PREFS:temp-noname\.tex"
  87. #                 message "Saving $newDoc..."
  88. #                 set fd [open $newDoc "w"]
  89. #                 puts $fd $text
  90. #                 close $fd
  91. #                 set currentWin $newDoc
  92. #                 typeset $currentWin
  93. #             } else {
  94. #                 beep
  95. #                 message "selection not in document environment"
  96. #             }
  97. #         } else {
  98. #             beep
  99. #             message "selection not in document environment"
  100. #         }
  101. #     } else {
  102. #         beep
  103. #         message "no selection"
  104. #     }
  105. # }
  106.  
  107. proc typesetSelection {} {
  108.     global PREFS
  109.     if { [isSelection] } then { 
  110.         set pos1 [getPos]
  111.         if { [isInDocument] } then {
  112.             exchangePointAndMark
  113.             set pos2 [getPos]
  114.             if { [isInDocument] } then {
  115.                 # fall through
  116.             } else {
  117.                 beep
  118.                 set msg "Selection not in document environment.  Continue?"
  119.                 if { [askyesno $msg] == "no" } then { return }
  120.             }
  121.         } else {
  122.             beep
  123.             set msg "Selection not in document environment.  Continue?"
  124.             if { [askyesno $msg] == "no" } then { return }
  125.             set pos2 [selEnd]
  126.         }
  127.         set body "\r[getText $pos1 $pos2]\r"
  128.         set pattern {(\\documentclass.*)\\begin\{document\}}
  129.         set searchText [getText 0 [maxPos]]
  130.         if {![regexp $pattern $searchText dummy preamble]} then {
  131.             set preamble "\\documentclass\{article\}\r"
  132.         }
  133.         append text $preamble [buildEnvironment "document" "" $body "\r"]
  134.         select $pos1 $pos2
  135.         set newDoc "$PREFS:temp-noname\.tex"
  136.         message "Saving $newDoc..."
  137.         set fd [open $newDoc "w"]
  138.         puts $fd $text
  139.         close $fd
  140.         set currentWin $newDoc
  141.         typeset $currentWin
  142.     } else {
  143.         beep
  144.         message "no selection"
  145.     }
  146. }
  147.  
  148. proc typeset {filename} {
  149.     global texPath TeXmodeVars
  150.     
  151.     # Check if a TeX app is running.  If not, open the app named in 
  152.     # $texPath (if defined) or have the user select an app via a
  153.     # standard file dialog.  Leave the TeX app in the background.
  154.     set appName [checkRunning TeX {OTEX *TEX *XeT MPS* TeX+} texPath 0]
  155.     
  156.     if {[string match {OzTeX*} $appName]} {
  157.         set isOzTeX 1
  158.     } elseif {[string match {Euro-OzTeX*} $appName]} {
  159.         set isOzTeX 1
  160.     } elseif {[string match {Textures*} $appName]} {
  161.         set isTextures 1
  162.     } elseif {[string match {DirectTeX*} $appName]} {
  163.         set isDirectTeXPro 1
  164.     } elseif {[string match {*tex} $appName]} {
  165.         set isCMacTeX 1
  166.     } elseif {[string match {MPW*} $appName]} {
  167.         set isDirectTeX 1
  168.     } else {
  169.         alertnote "Sorry, I don't know how to talk to \"$appName\"."
  170.         return
  171.     }
  172.     
  173.     # Conditionally bring the TeX app to the foreground:
  174.     if {$TeXmodeVars(runTeXInBackground) == 0} { switchTo $appName }
  175.     
  176.     # Typeset the document:
  177.     if {$isOzTeX} {
  178.         sendOpenEvent -n $appName $filename
  179.     } elseif {$isTextures} {
  180.         # Choose one of the following three options:
  181.         # dosc -c '*TEX' -s [getText 0 [maxPos]] -r
  182.         # sendOpenEvent -n $appName $filename
  183.         dosc -c '*TEX' -f [lindex [winNames -f] 0] -r
  184.     } elseif {$isDirectTeXPro} {
  185.         dosc -c 'TeX+' -s "ProjectMgr -t LaTeX \"$filename\"; SelectApp; MenuCommand 1 4"
  186.     } elseif {$isCMacTeX} {
  187.         dosc -n $appName -k 'aevt' -e 'odoc' -r -f $filename
  188.     } elseif {$isDirectTeX} {
  189.         set script "Begin; ChangeTeXProject '$filename' -check -confirm || Exit 0;\
  190.                       Execute \"{dt_TeXProject}\"; TeXMenu -tex -formats; End ╖ Dev:Null;\
  191.                       RunSession 1 ╖ Dev:Null"
  192.         dosc -r -n $appName -s $script
  193.     }
  194. }
  195.  
  196.  
  197. #--------------------------------------------------------------------------
  198. # Goto:
  199. #--------------------------------------------------------------------------
  200.  
  201. # Switch to (but don't execute) any of the following applications.
  202. proc latex {} {
  203.     global texPath
  204.     if {![catch {getFileSig $texPath} sig]} {
  205.         set appName [checkRunning TeX $sig texPath]
  206.     } else {
  207.         set appName [checkRunning TeX {OTEX *TEX *XeT MPS* TeX+} texPath]
  208.     }
  209.     if {[string length $appName] > 0} {
  210.         switchTo $appName
  211.     }
  212. }
  213. proc bibtex {} {
  214.     global bibtexPath
  215.     set appName [checkRunning BibTeX BIBt bibtexPath]
  216.     if {![string length $appName]} return
  217.     switchTo $appName
  218. }
  219. proc makeindex {} {
  220.     global makeindexPath
  221.     set appName [checkRunning MakeIndex Midx makeindexPath]
  222.     if {![string length $appName]} return
  223.     switchTo $appName
  224. }
  225.  
  226. # Find the next or previous environment.  Search forward (or backward, 
  227. # depending on $forward) for either \begin or \end.  If \begin is found, 
  228. # search forward for corresponding \end; otherwise, search backward for 
  229. # corresponding \begin.  Select the found environment, or display an 
  230. # error message if no environment is found.
  231. proc findEnvironment {forward} {
  232.     set searchString1 {^[ \t]*\\begin\{[^\{\}]*\}|\\end\{[^\{\}]*\}[ \t]*\r?}
  233.     set searchPos [getPos]
  234.     if { [isSelection] } then { 
  235.         if { $forward } then {
  236.             set searchPos [selEnd]
  237.         } else {
  238.             set searchPos [expr $searchPos - 1]
  239.         }
  240.     } else {
  241.         if { $forward } then {
  242.             set searchPos [expr $searchPos + 1]
  243.         } else {
  244.             set searchPos [expr $searchPos - 1]
  245.         }
  246.     }
  247.     set searchResult [search -s -f $forward -r 1 -n $searchString1 $searchPos]
  248.     if {[string length $searchResult]} then {
  249.         set begPos [lindex $searchResult 0]
  250.         set endPos [lindex $searchResult 1]
  251.         set searchText [getText $begPos $endPos]
  252.         regexp {\{(.*)\}} $searchText dummy envName
  253.         if {[string match {*begin*} $searchText]} {
  254.             set begEnv $begPos
  255.             append searchString2 {\\end\{} $envName {\}[ \t]*\r?}
  256.             set searchPos $endPos
  257.             set searchResult [search -s -f 1 -r 1 -n $searchString2 $searchPos]
  258.             if {[string length $searchResult]} {
  259.                 set endPos [lindex $searchResult 1]
  260.                 return [list $begPos $endPos]
  261.             } else {
  262.                 return "matching \\end not found"
  263.             }
  264.         } else {
  265.             set endEnv $endPos
  266.             append searchString2 {^[ \t]*\\begin\{} $envName {\}}
  267.             set searchPos $begPos
  268.             set searchResult [search -s -f 0 -r 1 -n $searchString2 $searchPos]
  269.             if {[string length $searchResult]} {
  270.                 set begPos [lindex $searchResult 0]
  271.                 return [list $begPos $endPos]
  272.             } else {
  273.                 return "matching \\begin not found"
  274.             }
  275.         }
  276.     } else {
  277.         if { $forward } then {
  278.             return "next environment not found"
  279.         } else {
  280.             return "previous environment not found"
  281.         }
  282.     }
  283. }
  284.  
  285. proc prevEnvironment {} {
  286.     global searchNoisily
  287.     set findResult [findEnvironment 0]
  288.     if {[llength $findResult] == 2} then {
  289.         goto [lindex $findResult 0]
  290.     } else {
  291.         if {$searchNoisily} {beep}
  292.         message $findResult
  293.     }
  294. }
  295. proc nextEnvironment {} {
  296.     global searchNoisily
  297.     set findResult [findEnvironment 1]
  298.     if {[llength $findResult] == 2} then {
  299.         goto [lindex $findResult 0]
  300.     } else {
  301.         if {$searchNoisily} {beep}
  302.         message $findResult
  303.     }
  304. }
  305. proc prevEnvironmentSelect {} {
  306.     global searchNoisily
  307.     set forward 0
  308.     set findResult [findEnvironment $forward]
  309.     if {[llength $findResult] == 2} then {
  310.         set endPos [lindex $findResult 1]
  311. #         if { [regexp {\r} [lookAt [expr $endPos + 1]]] } then {
  312. #             set endPos [expr $endPos + 1]
  313. #         }
  314.         select [lindex $findResult 0] $endPos
  315.     } else {
  316.         if { $searchNoisily } {beep}
  317.         message $findResult
  318.     }
  319. }
  320. proc nextEnvironmentSelect {} {
  321.     global searchNoisily
  322.     set forward 1
  323.     set findResult [findEnvironment $forward]
  324.     if {[llength $findResult] == 2} then {
  325.         set endPos [lindex $findResult 1]
  326. #         if { [regexp {\r} [lookAt [expr $endPos + 1]]] } then {
  327. #             set endPos [expr $endPos + 1]
  328. #         }
  329.         select [lindex $findResult 0] $endPos
  330.     } else {
  331.         if { $searchNoisily } {beep}
  332.         message $findResult
  333.     }
  334. }
  335.  
  336. # Find a LaTeX command in either direction.  It's up to the calling
  337. # procedure to pass the correct starting position of the search.
  338. proc findCommand {pos direction} {
  339. #    Handle "\ " and "\[" separately:
  340.     set searchString {(\\([^a-zA-Z\t\r* []|[a-zA-Z]+)\*?)|([^\\]\\\ )|([^\\]\\\[)}
  341.     set searchResult [search -s -f $direction -r 1 -n $searchString $pos]
  342.     if { [string length $searchResult] } {
  343.         set begPos [lindex $searchResult 0]
  344.         set endPos [lindex $searchResult 1]
  345.         set lastChar [lookAt [expr $endPos - 1]]
  346.         if {$lastChar == "\ " || $lastChar == "\["} then {
  347.             return [list [expr $begPos + 1] $endPos]
  348.         } else {}
  349.     }
  350.     return $searchResult
  351. # Handles everything but "\ " and "\[":
  352. #     set searchString {\\([^a-zA-Z\t\r* []|[a-zA-Z]+)\*?}
  353. #     return [search -s -f $direction -r 1 -n $searchString $pos]
  354. }
  355. # Find and goto the beginning of the previous LaTeX command.
  356. proc prevCommand {} {
  357.     global searchNoisily
  358.     set pos [getPos]
  359.     if {$pos > 0} then {
  360.         set searchResult [findCommand [expr $pos - 1] 0]
  361.         if { [string length $searchResult] } {
  362.             goto [lindex $searchResult 0]
  363.             return
  364.         } else {}
  365.     }
  366.     if { $searchNoisily } {beep}
  367.     message "previous command not found"
  368. }
  369. # Find and goto the beginning of the next LaTeX command.
  370. proc nextCommand {} {
  371.     global searchNoisily
  372.     set pos [getPos]
  373.     if {$pos < [maxPos]} then {
  374.         set searchResult [findCommand [expr $pos + 1] 1]
  375.         if { [string length $searchResult] } {
  376.             goto [lindex $searchResult 0]
  377.             return
  378.         } else {}
  379.     }
  380.     if { $searchNoisily } {beep}
  381.     message "next command not found"
  382. }
  383. # Select the previous LaTeX command, but do not attempt to select
  384. # any associated argument.
  385. proc prevCommandSelect {} {
  386.     global searchNoisily
  387.     set pos [getPos]
  388.     if {$pos > 0} then {
  389.         set searchResult [findCommand [expr $pos - 1] 0]
  390.         if { [string length $searchResult] } {
  391.             eval select $searchResult
  392.             return
  393.         } else {}
  394.     }
  395.     if { $searchNoisily } {beep}
  396.     message "previous command not found"
  397. }
  398. # Select the next LaTeX command, but do not attempt to select
  399. # any associated argument.
  400. proc nextCommandSelect {} {
  401.     global searchNoisily
  402.     set pos [getPos]
  403.     if {$pos < [maxPos]} then {
  404.         if { [isSelection] } then {
  405.             set pos [expr $pos + 1]
  406.         }
  407.         set searchResult [findCommand $pos 1]
  408.         if { [string length $searchResult] } {
  409.             eval select $searchResult
  410.             return
  411.         } else {}
  412.     }
  413.     if { $searchNoisily } {beep}
  414.     message "next command not found"
  415. }
  416.  
  417. # Find a LaTeX command with arguments in either direction.  It's up 
  418. # to the calling procedure to pass the starting position of the search.
  419. # (Handles everything but "\ " and commands whose arguments contain
  420. # embedded braces.)
  421. proc findCommandWithArgs {pos direction} {
  422.     set searchString {\\([^a-zA-Z\t\r]|[a-zA-Z]+\*?)(\[.*\])*({[^{}]*})*}
  423.     return [search -s -f $direction -r 1 -n $searchString $pos]
  424. }
  425. # Select the previous LaTeX command and any associated arguments.
  426. proc prevCommandSelectWithArgs {} {
  427.     global searchNoisily
  428.     set pos [getPos]
  429.     if {$pos > 0} then {
  430.         set searchResult [findCommandWithArgs [expr $pos - 1] 0]
  431.         if { [string length $searchResult] } {
  432.             eval select $searchResult
  433.             return
  434.         } else {}
  435.     }
  436.     if { $searchNoisily } {beep}
  437.     message "previous command not found"
  438. }
  439. # Select the next LaTeX command and any associated arguments.
  440. proc nextCommandSelectWithArgs {} {
  441.     global searchNoisily
  442.     set pos [getPos]
  443.     if {$pos < [maxPos]} then {
  444.         if { [isSelection] } then {
  445.             set pos [expr $pos + 1]
  446.         }
  447.         set searchResult [findCommandWithArgs $pos 1]
  448.         if { [string length $searchResult] } {
  449.             eval select $searchResult
  450.             return
  451.         } else {}
  452.     }
  453.     if { $searchNoisily } {beep}
  454.     message "next command not found"
  455. }
  456.  
  457. # Find a LaTeX sectioning command in either direction.  It's up to 
  458. # the calling procedure to pass the starting position of the search.
  459. proc findSection {pos direction} {
  460.     global funcExprAlt
  461.     return [search -s -f $direction -r 1 -n $funcExprAlt $pos]
  462. }
  463. # Select the previous LaTeX sectioning command.
  464. proc prevSection {} {
  465.     global searchNoisily
  466.     set pos [getPos]
  467.     if {$pos > 0} then {
  468.         set searchResult [findSection [expr $pos - 1] 0]
  469.         if { [string length $searchResult] } {
  470.             eval select $searchResult
  471.             return
  472.         } else {}
  473.     }
  474.     if { $searchNoisily } {beep}
  475.     message {previous section not found}
  476. }
  477. # Select the next LaTeX sectioning command.
  478. proc nextSection {} {
  479.     global searchNoisily
  480.     set pos [getPos]
  481.     if {$pos < [maxPos]} then {
  482.         if { [isSelection] } then {
  483.             set pos [expr $pos + 1]
  484.         }
  485.         set searchResult [findSection $pos 1]
  486.         if { [string length $searchResult] } {
  487.             eval select $searchResult
  488.             return
  489.         } else {}
  490.     }
  491.     if { $searchNoisily } {beep}
  492.     message {next section not found}
  493. }
  494. proc prevSectionSelect {} {
  495.     global searchNoisily
  496.     set pos [getPos]
  497.     if {$pos > 0} then {
  498.         set searchResult [findSection [expr $pos - 1] 0]
  499.         if { [string length $searchResult] } {
  500.             set begPos [lindex $searchResult 0]
  501.             set searchPos [expr [lindex $searchResult 1] + 1]
  502.             set searchResult [findSection $searchPos 1]
  503.             if { [string length $searchResult] } {
  504.                 set endPos [lindex $searchResult 0]
  505.             } else {
  506.                 set searchResult [search -s -f 1 -r 0 -n "\\end{document}" $searchPos]
  507.                 set endPos [lindex $searchResult 0]
  508.             }
  509.             select $begPos $endPos
  510.             return
  511.         } else {}
  512.     }
  513.     if { $searchNoisily } {beep}
  514.     message {previous section not found}
  515. }
  516. # Select the next LaTeX sectioning command.
  517. proc nextSectionSelect {} {
  518.     global searchNoisily
  519.     set pos [getPos]
  520.     if {$pos < [maxPos]} then {
  521.         if { [isSelection] } then {
  522.             set pos [expr $pos + 1]
  523.         }
  524.         set searchResult [findSection $pos 1]
  525.         if { [string length $searchResult] } {
  526.             set begPos [lindex $searchResult 0]
  527.             set searchPos [expr [lindex $searchResult 1] + 1]
  528.             set searchResult [findSection $searchPos 1]
  529.             if { [string length $searchResult] } {
  530.                 set endPos [lindex $searchResult 0]
  531.             } else {
  532.                 set searchResult [search -s -f 1 -r 0 -n "\\end{document}" $searchPos]
  533.                 set endPos [lindex $searchResult 0]
  534.             }
  535.             select $begPos $endPos
  536.             return
  537.         } else {}
  538.     }
  539.     if { $searchNoisily } {beep}
  540.     message {next section not found}
  541. }
  542.  
  543. # Find a LaTeX subsectioning command in either direction.  It's up to 
  544. # the calling procedure to pass the starting position of the search.
  545. proc findSubsection {pos direction} {
  546.     global funcExpr
  547.     return [search -s -f $direction -r 1 -n $funcExpr $pos]
  548. }
  549. proc prevSubsection {} {
  550.     global searchNoisily
  551.     set pos [getPos]
  552.     if {$pos > 0} then {
  553.         set searchResult [findSubsection [expr $pos - 1] 0]
  554.         if { [string length $searchResult] } {
  555.             eval select $searchResult
  556.             return
  557.         } else {}
  558.     }
  559.     if { $searchNoisily } {beep}
  560.     message {previous (sub)*section not found}
  561. }
  562. # Select the next LaTeX sectioning command.
  563. proc nextSubsection {} {
  564.     global searchNoisily
  565.     set pos [getPos]
  566.     if {$pos < [maxPos]} then {
  567.         if { [isSelection] } then {
  568.             set pos [expr $pos + 1]
  569.         }
  570.         set searchResult [findSubsection $pos 1]
  571.         if { [string length $searchResult] } {
  572.             eval select $searchResult
  573.             return
  574.         } else {}
  575.     }
  576.     if { $searchNoisily } {beep}
  577.     message {next (sub)*section not found}
  578. }
  579. proc prevSubsectionSelect {} {
  580.     global searchNoisily
  581.     set pos [getPos]
  582.     if {$pos > 0} then {
  583.         set searchResult [findSubsection [expr $pos - 1] 0]
  584.         if { [string length $searchResult] } {
  585.             set begPos [lindex $searchResult 0]
  586.             set endPos [lindex $searchResult 1]
  587.             set searchPos [expr $endPos + 1]
  588.             set commandName [extractCommandName [getText $begPos $endPos]]
  589.             if {[string match {section*} $commandName]} then {
  590.                 set searchResult [findSection $searchPos 1]
  591.             } else {
  592.                 set searchResult [findSubsection $searchPos 1]
  593.             }
  594.             if { [string length $searchResult] } {
  595.                 set endPos [lindex $searchResult 0]
  596.             } else {
  597.                 set searchResult [search -s -f 1 -r 0 -n "\\end{document}" $searchPos]
  598.                 set endPos [lindex $searchResult 0]
  599.             }
  600.             select $begPos $endPos
  601.             return
  602.         } else {}
  603.     }
  604.     if { $searchNoisily } {beep}
  605.     message {previous (sub)*section not found}
  606. }
  607. # Select the next LaTeX sectioning command.
  608. proc nextSubsectionSelect {} {
  609.     global searchNoisily
  610.     set pos [getPos]
  611.     if {$pos < [maxPos]} then {
  612.         if { [isSelection] } then {
  613.             set pos [expr $pos + 1]
  614.         }
  615.         set searchResult [findSubsection $pos 1]
  616.         if { [string length $searchResult] } {
  617.             set begPos [lindex $searchResult 0]
  618.             set endPos [lindex $searchResult 1]
  619.             set searchPos [expr $endPos + 1]
  620.             set commandName [extractCommandName [getText $begPos $endPos]]
  621.             if {[string match {section*} $commandName]} then {
  622.                 set searchResult [findSection $searchPos 1]
  623.             } else {
  624.                 set searchResult [findSubsection $searchPos 1]
  625.             }
  626.             if { [string length $searchResult] } {
  627.                 set endPos [lindex $searchResult 0]
  628.             } else {
  629.                 set searchResult [search -s -f 1 -r 0 -n "\\end{document}" $searchPos]
  630.                 set endPos [lindex $searchResult 0]
  631.             }
  632.             select $begPos $endPos
  633.             return
  634.         } else {}
  635.     }
  636.     if { $searchNoisily } {beep}
  637.     message {next (sub)*section not found}
  638. }
  639.  
  640. proc gotoTabStop {dirIndicator} {
  641.     set pos [getPos]
  642.     if {$dirIndicator} then {
  643.         if {$pos == [maxPos]} {return 0}
  644.     } else {
  645.         if {$pos == 0} {
  646.             set pos [expr $pos - 1]
  647.             return 0
  648.         }
  649.     }
  650.     set searchResult [search -s -n -f $dirIndicator -m 0 -i 1 -r 0 {Ñ} $pos]
  651.     if {[string length $searchResult]} then {
  652.         goto [lindex $searchResult 0]
  653.         return 1
  654.     } else {
  655.         return 0
  656.     }
  657. }
  658. proc nextTabStop {} {
  659.     global searchNoisily
  660.     set forward 1
  661.     if {[gotoTabStop $forward]} then {
  662.         deleteChar
  663.     } else {
  664.         if {$searchNoisily} {beep}
  665.         message "tab stop not found"
  666.     }
  667. }
  668. proc prevTabStop {} {
  669.     global searchNoisily
  670.     set forward 0
  671.     if {[gotoTabStop $forward]} then {
  672.         deleteChar
  673.     } else {
  674.         if {$searchNoisily} {beep}
  675.         message "tab stop not found"
  676.     }
  677. }
  678. # Goto the nth tab stop.  A nonzero argument is non-interactive
  679. # (for use in Tcl procs) and not validated.
  680. proc nthTabStop {{numTabStops 0}} {
  681.     global searchNoisily promptNoisily useStatusBar
  682.     if {$numTabStops == 0} then {
  683.         if {$promptNoisily && $useStatusBar} {beep}
  684.         catch {sPrompt "How many tab stops?" "3"} numTabStops
  685.         if {$numTabStops == "cancel" || $numTabStops == 0} then {
  686.             return
  687.         } elseif {![isInteger $numTabStops]} then {
  688.             beep
  689.             message "invalid input:  integer required"
  690.             return
  691.         }
  692.     }
  693.     set currentPos [getPos]
  694.     if {$numTabStops > 0} {set forward 1} {set forward 0}
  695.     set maxits [expr abs($numTabStops)]
  696.     if {![gotoTabStop $forward]} then {
  697.         if {$searchNoisily} {beep}
  698.         message "tab stop not found"
  699.         goto $currentPos
  700.         return
  701.     }
  702.     for {set i 1} {$i < $maxits} {incr i} {
  703.         if {$forward} {forwardChar} {backwardChar}
  704.         if {![gotoTabStop $forward]} then {
  705.             if {$searchNoisily} {beep}
  706.             message "tab stop not found"
  707.             goto $currentPos
  708.             return
  709.         }
  710.     }
  711.     deleteChar
  712. }
  713.  
  714. #--------------------------------------------------------------------------
  715. # Utilities:
  716. #--------------------------------------------------------------------------
  717.  
  718. # A keyboard-bound method of accessing menu commands.  Assumes the 
  719. # existence of two procs: 1) a proc called 'get___Menu', which 
  720. # returns the menu to be processed; and 2) a proc called '___MenuItem',
  721. # which filters menu items.  For example, in latex.tcl there are procs
  722. # called 'getLaTeXMenu' and 'LaTeXMenuItem' (see latexMenu.tcl).  To 
  723. # choose a command from the LaTeX menu, execute 'chooseCommand LaTeX' 
  724. # from the Tcl shell, or from within a proc.
  725.  
  726. proc chooseCommand {mode {men {}} {level 1}} {
  727.     watchCursor
  728.     # If the first time through, get the menu:
  729.     if {![string length $men]} {
  730.         if {$level == 1} {
  731.             set men    [get${mode}Menu]
  732.         } else {
  733.             error "empty submenu"
  734.         }
  735.     }
  736.     # Process the menu:
  737.     foreach    item $men {
  738.         regsub -all {[<!/].} $item {} item
  739.         regsub -all {╔}    $item {} item
  740.         lappend    menOut $item
  741.         if {[string match "menu*" $item]} {
  742.             if {[set ind [lsearch $item {-n}]] >= 0} {
  743.                 lappend    top "[lindex $item [incr    ind]]:"
  744.             }
  745.         } elseif {![string match "(*" $item]} {
  746.             lappend    top $item
  747.         }
  748.     }
  749.     # Present the menu items to the user:
  750.     set res    [listpick -p "$mode menu (level $level):" $top]
  751.     # Either execute a command or recurse on a submenu:
  752.     if {[lsearch $menOut $res] >= 0} {
  753.         ${mode}MenuItem dummy    $res
  754.     } else {
  755.         set res [string trimright $res {:}]
  756.         foreach    item $menOut {
  757.             if {[set ind [lsearch $item $res]] >= 0} {
  758.                 return [chooseCommand $mode [lindex $item end] [incr level]]
  759.             }
  760.         }
  761.     }
  762. }
  763.  
  764. proc insertLiteralTab {} {
  765.     if {[isSelection]} then {
  766.         deleteSelection
  767.     }
  768.     insertText "\t"
  769. }
  770.  
  771. proc insertTabStop {} {
  772.     if {[isSelection]} then {
  773.         deleteSelection
  774.     }
  775.     insertText "Ñ"
  776. }
  777.  
  778. proc insertReference {} {
  779.     set end [maxPos]
  780.     set pos 0
  781.     set labels {}
  782.     
  783.     set exp {\\label\{(.*)\}}
  784.     while {![catch {search -s -f 1 -r 1 -m 0 -i 0 $exp $pos} res]} {
  785.         set start [lindex $res 0]
  786.         set end [lindex $res 1]
  787.         set text [getText $start $end]
  788.         regexp {\{(.*)\}} $text dummy label
  789.         lappend labels $label
  790.         set pos [expr $end +1]
  791.     }
  792.  
  793.     set ref [listpick -p "Select a reference to insert" [lsort $labels]]
  794.     if {[string length $ref]} {
  795.         insertText "\\ref\{$ref\}"
  796.     }    
  797. }
  798.  
  799. # Removes all tab stops from the current selection (if there is one) 
  800. # or the current document, maintaining the cursor position in the 
  801. # latter case.
  802. proc deleteTabStops {} {
  803.     global searchNoisily
  804.     watchCursor
  805.     set subs1 0; set subs2 0; set subs3 0
  806.     set pos [getPos]
  807.     if {[set start $pos] == [set end [selEnd]]} {
  808.         set messageString "document"
  809.         set start 0
  810.         set end [maxPos]
  811.         set text1 [getText $start $pos]
  812.         set subs1 [regsub -all {Ñ} $text1 {} text1]
  813.         set text2 [getText $pos $end]
  814.         set subs2 [regsub -all {Ñ} $text2 {} text2]
  815.         append text $text1 $text2
  816.     } else {
  817.         set messageString "selection"
  818.         set text [getText $start $end]
  819.         set subs3 [regsub -all {Ñ} $text {} text]
  820.     }
  821.     if {$subs1 || $subs2 || $subs3} then {
  822.         replaceText $start $end $text
  823.         if {$messageString == "document"} then {
  824.             goto [expr $pos - $subs1]
  825.         } else {
  826.             set end [getPos]
  827.             select $start $end
  828.         }
  829.         set subs [expr $subs1 + $subs2 + $subs3]
  830.         message "$subs tab stops removed from $messageString"
  831.     } else {
  832.         if {$searchNoisily} {beep}
  833.         message "no tab stops found in $messageString"
  834.     }
  835. }
  836.  
  837. # Delete all unnecessary comments from the current document:
  838. proc deleteComments {} {
  839.     case [askyesno "Warning!  This operation can not be undone.  \
  840.                     Continue anyway?"] in {
  841.         "yes" {}
  842.         "no" { return }
  843.     }
  844.     replaceString {}
  845.     eval select [search -f 1 -r 1 -i 1 -m 0 -- {^[ \t]*%.*\r} 0]
  846.     replaceAll
  847.     
  848.     replaceString {}
  849.     eval select [search -f 1 -r 1 -i 1 -m 0 -- {[ \t]+%.*} 0]
  850.     replaceAll
  851.     
  852.     replaceString {\1%}
  853.     eval select [search -f 1 -r 1 -i 1 -m 0 -- {([^\\](\\\\)*)%.*} 0]
  854.     replaceAll
  855. }
  856.  
  857. # Converts all straight quotes to their TeX equivalents.
  858. proc convertQuotes {} {
  859.     global searchNoisily
  860.     message "working╔"
  861.     watchCursor
  862.     set messageString "selection"
  863.     if {[set start [getPos]] == [set end [selEnd]]} {
  864.         set messageString "document"
  865.         set start 0
  866.         set end [maxPos]
  867.     }
  868.     set text [getText $start $end]
  869.     # Convert all left double quotes:
  870.     set convert1 [regsub -all "\(\^\|\[\ \r\t\(\[\{\]\)\"" $text {\1``} text]
  871.     # Convert all right double quotes:
  872.     set convert2 [regsub -all "\(\[\^\\\\\]\)\"" $text {\1''} text]
  873.     # Convert all left single quotes:
  874.     set convert3 [regsub -all "\(\^\|\[\ \r\t\(\[\{\]\)\'" $text {\1`} text]
  875.     if {$convert1 || $convert2 || $convert3} then {
  876.         replaceText $start $end $text
  877.         message "all quotes in $messageString converted"
  878.     } else {
  879.         if {$searchNoisily} {beep}
  880.         message "no quotes found in $messageString"
  881.     }
  882. }
  883.  
  884. # Returns true if the argument contains non-literal double dollar
  885. # signs, and false otherwise.
  886. proc containsDoubleDollarSigns {text} {
  887.     return [regexp {(^|[^\\])\$\$} $text]
  888. }
  889.  
  890. # Converts all $$...$$ pairs to \[...\] and returns the number of such 
  891. # pairs converted.  If the dollar signs are unbalanced, does nothing 
  892. # and returns -1.
  893. proc convertDoubleDollarSigns {} {
  894.     watchCursor
  895.     set messageString "selection"
  896.     if {[set start [getPos]] == [set end [selEnd]]} {
  897.         set messageString "document"
  898.         set start 0
  899.         set end [maxPos]
  900.     }
  901.     set text [getText $start $end]
  902.     set subs [regsub -all {(^|[^\\])\$\$([^$]*)\$\$} $text {\1\\[\2\\]} text]
  903.     if {[containsDoubleDollarSigns $text]} then {return -1}
  904.     if {$subs} then {
  905.         replaceText $start $end $text
  906.     }
  907.     return [expr $subs]
  908. }
  909.  
  910. # Returns true if the argument contains a non-literal dollar sign,
  911. # and false otherwise.
  912. proc containsSingleDollarSign {text} {
  913.     return [regexp {(^|[^\\])\$} $text]
  914. }
  915.  
  916. # Converts all $...$ pairs to \(...\), maintains the cursor position, 
  917. # and returns the number of such pairs converted.  If the dollar signs 
  918. # are unbalanced, does nothing and returns -1.
  919. proc convertSingleDollarSigns {} {
  920.     watchCursor
  921.     set subs1 0; set subs2 0; set subs3 0
  922.     set pos [getPos]; set pos2 $pos
  923.     if {[set start $pos] == [set end [selEnd]]} {
  924.         set isSelection 0
  925.         set start 0
  926.         set end [maxPos]
  927.         set text1 [getText $start $pos]
  928.         set subs1 [regsub -all {(^|[^\\])\$([^$]*)\$} $text1 {\1\\(\2\\)} text1]
  929.         # Is there a dollar sign left over?  If so, search backward for this
  930.         # dollar sign and prepare to do a substitution on the text to the right
  931.         # of this dollar sign.
  932.         if {[containsSingleDollarSign $text1]} then {
  933.             set searchString {[^\\]\$}
  934.             set searchResult [search -s -n -f 0 -m 0 -i 1 -r 1 $searchString [expr $pos-1]]
  935.             set pos2 [lindex $searchResult 0]
  936.             set text1 [string range $text1 0 [expr $pos2 + (2 * $subs1)]]
  937.             set pos [expr $pos + 2]
  938.         }
  939.         set text2 [getText $pos2 $end]
  940.         set subs2 [regsub -all {(^|[^\\])\$([^$]*)\$} $text2 {\1\\(\2\\)} text2]
  941.         # Is there a dollar sign left over?  If so, it's unbalanced.
  942.         if {[containsSingleDollarSign $text2]} then {return -1}
  943.         append text $text1 $text2
  944.     } else {
  945.         set isSelection 1
  946.         set text [getText $start $end]
  947.         set subs3 [regsub -all {(^|[^\\])\$([^$]*)\$} $text {\1\\(\2\\)} text]
  948.         # Is there a dollar sign left over?  If so, it's unbalanced.
  949.         if {[containsSingleDollarSign $text]} then {return -1}
  950.     }
  951.     if {$subs1 || $subs2 || $subs3} then {
  952.         replaceText $start $end $text
  953.         # If there is a selection, just put it back.  Otherwise, adjust the
  954.         # cursor position based on the number of substitutions.
  955.         if {$isSelection} then {
  956.             set end [getPos]
  957.             select $start $end
  958.         } else {
  959.             goto [expr $pos + (2 * $subs1)]
  960.         }
  961.     }
  962.     return [expr $subs1 + $subs2 + $subs3]
  963. }
  964.  
  965. proc convertDollarSigns {} {
  966.     global searchNoisily
  967.     if {[isSelection]} then {
  968.         set messageString "selection"
  969.     } else {
  970.         set messageString "document"
  971.     }
  972.     set subs2 [convertDoubleDollarSigns]
  973.     if {$subs2 == -1} then {
  974.         beep
  975.         alertnote "unmatched double dollar signs in $messageString"
  976.     } else {
  977.         set subs1 [convertSingleDollarSigns]
  978.         if {$subs1 == -1} then {
  979.             beep
  980.             alertnote "unmatched single dollar sign in $messageString"
  981.         } elseif {$subs1 == 0 && $subs2 == 0} then {
  982.             if {$searchNoisily} {beep}
  983.             message "no dollar signs found in $messageString"
  984.         } else {
  985.             message "$subs1 pairs of \$...\$ and $subs2 pairs of \$\$...\$\$ removed from $messageString"
  986.         }
  987.     }
  988. }
  989.  
  990. proc removeAuxiliaryFiles {} {
  991.     set word ""
  992.     set removeSilently 0
  993.     set currentWin [lindex [winNames -f] 0]
  994.     set currentDir [file dirname $currentWin]
  995.     set currentDoc [file tail $currentWin]
  996.     set docBasename [file rootname $currentDoc]
  997. #     set docExtension [file extension $currentDoc]
  998.     set extensions {.aux .bbl .dvi .glo .idx .ind .lof .log .lot \
  999.               .toc .blg .clg .ilg .ps}
  1000.     foreach ext $extensions {
  1001.         message "Checking for *$ext files╔"
  1002.         set files [glob -nocomplain "$currentDir:*$ext"]
  1003.         foreach file $files {
  1004.             set word " more"
  1005.             if {$removeSilently} {
  1006.                 if {[catch {rm "$currentDir:*$ext"}]} then {
  1007.                     alertnote "not all \"*$ext\" files deleted"
  1008.                 }
  1009.                 break
  1010.             } else {
  1011.                 message ""
  1012.                 set filename [file tail $file]
  1013.                 case [buttonAlert "Remove \"$filename\"?" "yes" "no" {rm ext} {rm all} "cancel"] in {
  1014.                     "yes" {
  1015.                         message "Removing $filename╔"
  1016.                         if {[catch {removeFile "$currentDir:$filename"}]} then {
  1017.                             alertnote "\"$filename\" not deleted"
  1018.                         } else {
  1019.                             message $filename
  1020.                         }
  1021.                     }
  1022.                     "no" {}
  1023.                     "{rm ext}" {
  1024.                         if {[catch {rm "$currentDir:*$ext"}]} then {
  1025.                             alertnote "not all \"*$ext\" files deleted"
  1026.                         }
  1027.                         break
  1028.                     }
  1029.                     "{rm all}" {
  1030.                         if {[catch {rm "$currentDir:*$ext"}]} then {
  1031.                             alertnote "not all \"*$ext\" files deleted"
  1032.                         }
  1033.                         set removeSilently 1
  1034.                         break
  1035.                     }
  1036.                     "cancel" {return}
  1037.                 }
  1038.             }
  1039.         }
  1040.     }
  1041.     message "No$word files found"
  1042. }
  1043.  
  1044.  
  1045. #############################################################################
  1046. # 
  1047. # Paragraph Mode Macros
  1048. #
  1049. #############################################################################
  1050.  
  1051. #--------------------------------------------------------------------------
  1052. # Documents:
  1053. #--------------------------------------------------------------------------
  1054.  
  1055. proc letter {} {
  1056.     set    preamble "\r\\address\{%\r"
  1057.     append preamble "    Ñ    \\\\    % insert your name here\r"
  1058.     append preamble "    Ñ    \\\\    % insert your address here\r"
  1059.     append preamble "    Ñ    \\\\    % insert more address here\r"
  1060.     append preamble "    Ñ          % insert city-state-zip here\r"
  1061.     append preamble "\}\r\r"
  1062.     append preamble "\\date\{Ñ\}  % optional\r"
  1063.     append preamble "\\signature\{Ñ\}\r\r"
  1064.     set    body "\r\\begin\{letter\}\{%\r"
  1065.     append body "    Ñ    \\\\    % insert addressee's name here\r"
  1066.     append body "    Ñ    \\\\    % insert addressee's address here\r"
  1067.     append body "    Ñ    \\\\    % insert more address here\r"
  1068.     append body "    Ñ          % insert addressee's city-state-zip here\r"
  1069.     append body "\}\r\r"
  1070.     append body "\\opening\{Dear Ñ,\}\r\r"
  1071.     if {[isEmptyFile]} then {
  1072.         append body "% BODY OF LETTER\r"
  1073.         append body "Ñ\r\r"
  1074.     } else {
  1075.         if {[isDocumentSelected]} then {
  1076.             set text [getSelect]
  1077. #             deleteText 0 [maxPos]
  1078.             append body "$text\r"
  1079.         } else {
  1080.             alertnote "nonempty file:  delete text or \'Select All\'\
  1081.                 from the Edit menu"
  1082.             return
  1083.         }
  1084.     }
  1085.     append body "\\closing\{Sincerely,\}\r\r"
  1086.     append body "\\encl\{Ñ\}\r"
  1087.     append body "\\cc\{Ñ\}\r\r"
  1088.     append body "\\end\{letter\}\r\r"
  1089.     insertDocument "letter" $preamble $body
  1090.     nextTabStop
  1091.     message "enter option (or leave blank)"
  1092. }
  1093. proc article {} {
  1094.     wrapDocument "article"
  1095.     nextTabStop
  1096.     message "enter option (or leave blank)"
  1097. }
  1098. proc report {} {
  1099.     wrapDocument "report"
  1100.     nextTabStop
  1101.     message "enter option (or leave blank)"
  1102. }
  1103. proc book {} {
  1104.     wrapDocument "book"
  1105.     nextTabStop
  1106.     message "enter option (or leave blank)"
  1107. }
  1108. proc slides {} {
  1109.     wrapDocument "slides"
  1110.     nextTabStop
  1111.     message "enter option (or leave blank)"
  1112. }
  1113. proc custom {} {
  1114.     catch {prompt "What documentclass?" "article"} documentType
  1115.     if {$documentType != "cancel"} then {
  1116.         wrapDocument "$documentType" 
  1117.         nextTabStop
  1118.         message "enter option (or leave blank)"
  1119.     }
  1120. }
  1121.  
  1122. proc getOption {} {
  1123.     catch {prompt "Choose an option:" "11pt" "" "10pt" "11pt" "12pt" "(-" \
  1124.             "letterpaper" "legalpaper" "executivepaper" "a4paper" "a5paper" \
  1125.             "b5paper" "(-" "landscape" "(-" "final" "draft" "(-" \
  1126.             "oneside" "twoside" "(-" "openright" "openany" "(-" \
  1127.             "onecolumn" "twocolumn" "(-" "notitlepage" "titlepage" \
  1128.                   "openbib" "(-" "leqno" "(-" "fleqn"} optionName
  1129.     if {$optionName != "cancel"} then {
  1130.         return $optionName
  1131.     } else {
  1132.         return ""
  1133.     }
  1134. }
  1135. proc insertOption {option} {
  1136.     global searchNoisily
  1137.     set searchString {\\documentclass}
  1138.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  1139.     if {[llength $searchResult] == 0} then {
  1140.         if {$searchNoisily} {beep}
  1141.         message "can\'t find \\documentclass"
  1142.     } else {
  1143.         set nextCharPos [lindex $searchResult 1]
  1144.         goto $nextCharPos
  1145.         set nextChar [lookAt $nextCharPos]
  1146.         if {$nextChar == "\["} then {
  1147.             forwardChar
  1148.             insertText $option
  1149.             if {[lookAt [getPos]] != "\]"} then {
  1150.                 insertText ","
  1151.             }
  1152.         } elseif {$nextChar == "\{"} then {
  1153.             insertText "\[$option\]"
  1154.         } else {
  1155.             alertnote "unrecognizable \\documentclass statement"
  1156.         }
  1157.     }
  1158. }
  1159. proc options {} {
  1160.     set option [getOption]
  1161.     if {$option != ""} then {
  1162.         insertOption $option
  1163.     }
  1164. }
  1165. proc getPackage {} {
  1166.     catch {prompt "Choose a package:" "latexsym" "" \
  1167.                   "alltt" "amstex" "babel" "color" \
  1168.                   "graphics" "graphpap" "ifthen" "latexsym" "makeidx" \
  1169.                   "pict2e" "showidx"} packageName
  1170.     if {$packageName != "cancel"} then {
  1171.         return $packageName
  1172.     } else {
  1173.         return ""
  1174.     }
  1175. }
  1176. proc insertPackage {package} {
  1177.     global searchNoisily
  1178.     set begPos [getPos]
  1179.     set endPos [selEnd]
  1180.     append searchString {\\usepackage\{.*} $package {.*\}}
  1181.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  1182.     if {[llength $searchResult] == 0} then {
  1183.         set searchString {\\documentclass(\[.*\])?\{.*\}}
  1184.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  1185.         if {[llength $searchResult] == 0} then {
  1186.             if {$searchNoisily} {beep}
  1187.             message "can't find \\documentclass"
  1188.         } else {
  1189.             goto [lindex $searchResult 1]
  1190.             set txt "\r\\usepackage\{$package\}"
  1191.             set offset [string length $txt]
  1192.             set begPos [expr $begPos + $offset]
  1193.             set endPos [expr $endPos + $offset]
  1194.             insertText $txt
  1195.             select $begPos $endPos
  1196.         }
  1197.     } else {
  1198.         if {$searchNoisily} {beep}
  1199.         message "$package package already loaded"
  1200.     }
  1201. }
  1202. proc packages {} {
  1203.     set package [getPackage]
  1204.     if {$package != ""} then {
  1205.         insertPackage $package
  1206.     }
  1207. }
  1208. proc filecontents {} {
  1209.     global searchNoisily
  1210.     set searchString {\\documentclass}
  1211.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  1212.     if {[llength $searchResult] == 0} then {
  1213.         if {$searchNoisily} {beep}
  1214.         message "can\'t find \\documentclass"
  1215.         return
  1216.     } else {
  1217.         set prompt "File to be included:"
  1218.         if {[catch {getfile $prompt} path]} then {
  1219.             return
  1220.         } else {
  1221.             set fd [open $path]
  1222.             set text [read $fd]
  1223.             close $fd
  1224.             regsub -all "\xa" $text "\xd" text
  1225.             goto 0
  1226.             set envName "filecontents"
  1227.             set envArg "{[file tail $path]}"
  1228.             replaceText 0 0 [buildEnvironment $envName $envArg "$text\r" "\r\r"]
  1229.             goto 0
  1230.             message "file included"
  1231.         }
  1232.     }
  1233. }
  1234.  
  1235. #--------------------------------------------------------------------------
  1236. # Page Layout:
  1237. #--------------------------------------------------------------------------
  1238.  
  1239. proc maketitle {} {
  1240.     global searchNoisily
  1241.     set searchString {\\document(class|style)(\[.*\])?\{.*\}}
  1242.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  1243.     if {[llength $searchResult] == 0} then {
  1244.         if {$searchNoisily} {beep}
  1245.         message "can\'t find \\documentclass or \\documentstyle"
  1246.     } else {
  1247.         set searchPos [lindex $searchResult 1]
  1248.         set searchString {\\begin\{document\}}
  1249.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString $searchPos]
  1250.         if {[llength $searchResult] == 0} then {
  1251.             if {$searchNoisily} {beep}
  1252.             message "can\'t find \\begin\{document\}"
  1253.         } else {
  1254.             goto [lindex $searchResult 1]
  1255.             set currentPos [getPos]
  1256.             set txt "\r\r% Definition of title page:"
  1257.             append txt "\r\\title\{"
  1258.             append txt "\r\tÑ\r\}"
  1259.             append txt "\r\\author\{"
  1260.             append txt "\r\tÑ\t% insert author(s) here"
  1261.             append txt "\r\}"
  1262.             append txt "\r\\date\{Ñ\}\t% optional"
  1263.             append txt "\r\r\\maketitle"
  1264.             insertText $txt
  1265.             goto $currentPos
  1266.             nextTabStop
  1267.             message "insert title"
  1268.         }
  1269.     }
  1270. }
  1271. proc abstract {} { doWrapEnvironment "abstract" }
  1272. proc titlepage {} { doWrapEnvironment "titlepage" }
  1273. proc getPagestyle {} {
  1274.     catch {prompt "Choose a pagestyle:" "plain" "" "plain" "empty" \
  1275.                   "headings" "myheadings"} pagestyleName
  1276.     if {$pagestyleName != "cancel"} then {
  1277.         return $pagestyleName
  1278.     } else {
  1279.         return ""
  1280.     }
  1281. }
  1282. proc pagestyle {} {
  1283.     set pagestyleName [getPagestyle]
  1284.     if {$pagestyleName != ""} then {
  1285.         openingCarriageReturn
  1286.         insertObject "\\pagestyle\{$pagestyleName\}"
  1287.         closingCarriageReturn
  1288.     }
  1289. }
  1290. proc thispagestyle {} {
  1291.     set pagestyleName [getPagestyle]
  1292.     if {$pagestyleName != ""} then {
  1293.         openingCarriageReturn
  1294.         insertObject "\\thispagestyle\{$pagestyleName\}"
  1295.         closingCarriageReturn
  1296.     }
  1297. }
  1298. proc getPagenumberingStyle {} {
  1299.     catch {prompt "Choose a pagenumbering style:" "arabic" "" "arabic" \
  1300.                   "roman" "Roman" "alph" "Alph"} pagenumberingStyle
  1301.     if {$pagenumberingStyle != "cancel"} then {
  1302.         return $pagenumberingStyle
  1303.     } else {
  1304.         return ""
  1305.     }
  1306. }
  1307. proc pagenumbering {} {
  1308.     set pagenumberingStyle [getPagenumberingStyle]
  1309.     if {$pagenumberingStyle != ""} then {
  1310.         openingCarriageReturn
  1311.         insertObject "\\pagenumbering\{$pagenumberingStyle\}"
  1312.         closingCarriageReturn
  1313.     }
  1314. }
  1315. proc twocolumn {} {
  1316.     openingCarriageReturn
  1317.     insertObject "\\twocolumn"
  1318.     closingCarriageReturn
  1319. }
  1320. proc onecolumn {} {
  1321.     openingCarriageReturn
  1322.     insertObject "\\onecolumn"
  1323.     closingCarriageReturn
  1324. }
  1325.  
  1326. #--------------------------------------------------------------------------
  1327. # Sectioning:
  1328. #--------------------------------------------------------------------------
  1329.  
  1330. proc part {} {
  1331.     if {[wrapObject "\\part{" "}Ñ"]} then {
  1332.         message "don't forget the label"
  1333.     } else {
  1334.         message "type the part name and don't forget the label"
  1335.     }
  1336. }
  1337. proc chapter {} {
  1338.     if {[wrapObject "\\chapter{" "}Ñ"]} then {
  1339.         message "don't forget the label"
  1340.     } else {
  1341.         message "type the chapter name and don't forget the label"
  1342.     }
  1343. }
  1344. proc section {} {
  1345.     if {[wrapObject "\\section{" "}Ñ"]} then {
  1346.         message "don't forget the label"
  1347.     } else {
  1348.         message "type the section name and don't forget the label"
  1349.     }
  1350. }
  1351. proc subsection {} {
  1352.     if {[wrapObject "\\subsection{" "}Ñ"]} then {
  1353.         message "don't forget the label"
  1354.     } else {
  1355.         message "type the subsection name and don't forget the label"
  1356.     }
  1357. }
  1358. proc subsubsection {} {
  1359.     if {[wrapObject "\\subsubsection{" "}Ñ"]} then {
  1360.         message "don't forget the label"
  1361.     } else {
  1362.         message "type the subsubsection name and don't forget the label"
  1363.     }
  1364. }
  1365. proc paragraph {} {
  1366.     if {[wrapObject "\\paragraph{" "}Ñ"]} then {
  1367.         message "don't forget the label"
  1368.     } else {
  1369.         message "type the paragraph name and don't forget the label"
  1370.     }
  1371. }
  1372. proc subparagraph {} {
  1373.     if {[wrapObject "\\subparagraph{" "}Ñ"]} then {
  1374.         message "don't forget the label"
  1375.     } else {
  1376.         message "type the subparagraph name and don't forget the label"
  1377.     }
  1378. }
  1379. proc appendix {} {insertObject "\\appendix"}
  1380.  
  1381. #--------------------------------------------------------------------------
  1382. # Text Style:
  1383. #--------------------------------------------------------------------------
  1384.  
  1385. proc emph {} {
  1386.     if {[wrapObject "\\emph{" "}Ñ"]} then {
  1387.         message "selected text has been emphasized"
  1388.     } else {
  1389.         message "enter text to be emphasized"
  1390.     }
  1391. }
  1392. proc textup {} {
  1393.     if {[wrapObject "\\textup{" "}Ñ"]} then {
  1394.         message "selected text has upright shape"
  1395.     } else {
  1396.         message "enter text to have upright shape"
  1397.     }
  1398. }
  1399. proc textit {} {
  1400.     if {[wrapObject "\\textit{" "}Ñ"]} then {
  1401.         message "selected text has italic shape"
  1402.     } else {
  1403.         message "enter text to have italic shape"
  1404.     }
  1405. }
  1406. proc textsl {} {
  1407.     if {[wrapObject "\\textsl{" "}Ñ"]} then {
  1408.         message "selected text has slanted shape"
  1409.     } else {
  1410.         message "enter text to have slanted shape"
  1411.     }
  1412. }
  1413. proc textsc {} {
  1414.     if {[wrapObject "\\textsc{" "}Ñ"]} then {
  1415.         message "selected text has small caps shape"
  1416.     } else {
  1417.         message "enter text to have small caps shape"
  1418.     }
  1419. }
  1420. proc textmd {} {
  1421.     if {[wrapObject "\\textmd{" "}Ñ"]} then {
  1422.         message "selected text has been set in medium series"
  1423.     } else {
  1424.         message "enter text to be set in medium series"
  1425.     }
  1426. }
  1427. proc textbf {} {
  1428.     if {[wrapObject "\\textbf{" "}Ñ"]} then {
  1429.         message "selected text has been set in bold series"
  1430.     } else {
  1431.         message "enter text to be set in bold series"
  1432.     }
  1433. }
  1434. proc textrm {} {
  1435.     if {[wrapObject "\\textrm{" "}Ñ"]} then {
  1436.         message "selected text has been set with roman family"
  1437.     } else {
  1438.         message "enter text to be set using roman family"
  1439.     }
  1440. }
  1441. proc textsf {} {
  1442.     if {[wrapObject "\\textsf{" "}Ñ"]} then {
  1443.         message "selected text has been set with sans serif family"
  1444.     } else {
  1445.         message "enter text to be set using sans serif family"
  1446.     }
  1447. }
  1448. proc texttt {} {
  1449.     if {[wrapObject "\\texttt{" "}Ñ"]} then {
  1450.         message "selected text has been set with typewriter family"
  1451.     } else {
  1452.         message "enter text to be set using typewriter family"
  1453.     }
  1454. }
  1455. proc textnormal {} {
  1456.     if {[wrapObject "\\textnormal{" "}Ñ"]} then {
  1457.         message "selected text has been set with normal style"
  1458.     } else {
  1459.         message "enter text to be set using normal style"
  1460.     }
  1461. }
  1462.  
  1463. #--------------------------------------------------------------------------
  1464. # Text Size:
  1465. #--------------------------------------------------------------------------
  1466.  
  1467. proc tiny {} {
  1468.     if {[wrapObject "{\\tiny " "}Ñ"]} then {
  1469.         message "tiny text set"
  1470.     } else {
  1471.         message "enter tiny text"
  1472.     }
  1473. }
  1474. proc scriptsize {} {
  1475.     if {[wrapObject "{\\scriptsize " "}Ñ"]} then {
  1476.         message "scriptsize text set"
  1477.     } else {
  1478.         message "enter scriptsize text"
  1479.     }
  1480. }
  1481. proc footnotesize {} {
  1482.     if {[wrapObject "{\\footnotesize " "}Ñ"]} then {
  1483.         message "footnotesize text set"
  1484.     } else {
  1485.         message "enter footnotesize text"
  1486.     }
  1487. }
  1488. proc small {} {
  1489.     if {[wrapObject "{\\small " "}Ñ"]} then {
  1490.         message "small text set"
  1491.     } else {
  1492.         message "enter small text"
  1493.     }
  1494. }
  1495. proc normalsize {} {
  1496.     if {[wrapObject "{\\normalsize " "}Ñ"]} then {
  1497.         message "normalsize text set"
  1498.     } else {
  1499.         message "enter normalsize text"
  1500.     }
  1501. }
  1502. proc large {} {
  1503.     if {[wrapObject "{\\large " "}Ñ"]} then {
  1504.         message "large text set"
  1505.     } else {
  1506.         message "enter large text"
  1507.     }
  1508. }
  1509. proc Large {} {
  1510.     if {[wrapObject "{\\Large " "}Ñ"]} then {
  1511.         message "Large text set"
  1512.     } else {
  1513.         message "enter Large text"
  1514.     }
  1515. }
  1516. proc LARGE {} {
  1517.     if {[wrapObject "{\\LARGE " "}Ñ"]} then {
  1518.         message "LARGE text set"
  1519.     } else {
  1520.         message "enter LARGE text"
  1521.     }
  1522. }
  1523. proc huge {} {
  1524.     if {[wrapObject "{\\huge " "}Ñ"]} then {
  1525.         message "huge text set"
  1526.     } else {
  1527.         message "enter huge text"
  1528.     }
  1529. }
  1530. proc Huge {} {
  1531.     if {[wrapObject "{\\Huge " "}Ñ"]} then {
  1532.         message "Huge text set"
  1533.     } else {
  1534.         message "enter Huge text"
  1535.     }
  1536. }
  1537.  
  1538. #--------------------------------------------------------------------------
  1539. # International:
  1540. #--------------------------------------------------------------------------
  1541.  
  1542. proc {ÿ} {} {
  1543.     if {[wrapObject "\\`{" "}Ñ"]} then {
  1544.         message "accent set"
  1545.     } else {
  1546.         message "enter single character"
  1547.     }
  1548. }
  1549. proc {ù} {} {
  1550.     if {[wrapObject "\\'{" "}Ñ"]} then {
  1551.         message "accent set"
  1552.     } else {
  1553.         message "enter single character"
  1554.     }
  1555. }
  1556. proc {Ö} {} {
  1557.     if {[wrapObject "\\^{" "}Ñ"]} then {
  1558.         message "accent set"
  1559.     } else {
  1560.         message "enter single character"
  1561.     }
  1562. }
  1563. proc {Ü} {} {
  1564.     if {[wrapObject "\\\"{" "}Ñ"]} then {
  1565.         message "accent set"
  1566.     } else {
  1567.         message "enter single character"
  1568.     }
  1569. }
  1570. proc {¢} {} {
  1571.     if {[wrapObject "\\~{" "}Ñ"]} then {
  1572.         message "accent set"
  1573.     } else {
  1574.         message "enter single character"
  1575.     }
  1576. }
  1577. proc {ì} {} {insertObject "\\c\{c\}"}
  1578. proc {é} {} {insertObject "\\c\{C\}"}
  1579. proc {╧} {} {insertObject "\\oe"}
  1580. proc {╬} {} {insertObject "\\OE"}
  1581. proc {╛} {} {insertObject "\\ae"}
  1582. proc {«} {} {insertObject "\\AE"}
  1583. proc {î} {} {insertObject "\\aa"}
  1584. proc {ü} {} {insertObject "\\AA"}
  1585. proc {┐} {} {insertObject "\\o"}
  1586. proc {»} {} {insertObject "\\O"}
  1587. proc {º} {} {insertObject "\\ss"}
  1588. proc {└} {} {insertObject "?`"}
  1589. proc {┴} {} {insertObject "!`"}
  1590.  
  1591. #--------------------------------------------------------------------------
  1592. # Environments:
  1593. #--------------------------------------------------------------------------
  1594.  
  1595. proc enumerate {} {
  1596.     global promptNoisily useStatusBar
  1597.     set envName "enumerate"
  1598.     if {$promptNoisily && $useStatusBar} {beep}
  1599.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  1600.     if {$numberItems == "cancel"} then {
  1601.         return
  1602.     } elseif {![isPositiveInteger $numberItems]} then {
  1603.         beep
  1604.         message "invalid input:  unsigned, postive integer required"
  1605.         return
  1606.     }
  1607.     if {$numberItems} then {
  1608.         set body "\t\\item  Ñ"
  1609.         for {set i 1} {$i < $numberItems} {incr i} {
  1610.             append body "\r\r\t\\item  Ñ"
  1611.         }
  1612.         append body "\r"
  1613.     } else {
  1614.         set body "\tÑ\r"
  1615.     }
  1616.     if {[insertEnvironment $envName "" $body]} then {
  1617.         nextTabStop
  1618.         message "type first item"
  1619.     }
  1620. }
  1621. proc itemize {} {
  1622.     global promptNoisily useStatusBar
  1623.     set envName "itemize"
  1624.     if {$promptNoisily && $useStatusBar} {beep}
  1625.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  1626.     if {$numberItems == "cancel"} then {
  1627.         return
  1628.     } elseif {![isPositiveInteger $numberItems]} then {
  1629.         beep
  1630.         message "invalid input:  unsigned, postive integer required"
  1631.         return
  1632.     }
  1633.     if {$numberItems} then {
  1634.         set body "\t\\item  Ñ"
  1635.         for {set i 1} {$i < $numberItems} {incr i} {
  1636.             append body "\r\r\t\\item  Ñ"
  1637.         }
  1638.         append body "\r"
  1639.     } else {
  1640.         set body "\tÑ\r"
  1641.     }
  1642.     if {[insertEnvironment $envName "" $body]} then {
  1643.         nextTabStop
  1644.         message "type first item"
  1645.     }
  1646. }
  1647. proc description {} {
  1648.     global promptNoisily useStatusBar
  1649.     set envName "description"
  1650.     if {$promptNoisily && $useStatusBar} {beep}
  1651.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  1652.     if {$numberItems == "cancel"} then {
  1653.         return
  1654.     } elseif {![isPositiveInteger $numberItems]} then {
  1655.         beep
  1656.         message "invalid input:  unsigned, postive integer required"
  1657.         return
  1658.     }
  1659.     if {$numberItems} then {
  1660.         set body "\t\\item\[Ñ\]  Ñ"
  1661.         for {set i 1} {$i < $numberItems} {incr i} {
  1662.             append body "\r\r\t\\item\[Ñ\]  Ñ"
  1663.         }
  1664.         append body "\r"
  1665.     } else {
  1666.         set body "\tÑ\r"
  1667.     }
  1668.     if {[insertEnvironment $envName "" $body]} then {
  1669.         nextTabStop
  1670.         message "type first item label"
  1671.     }
  1672. }
  1673. proc thebibliography {} {
  1674.     global promptNoisily useStatusBar
  1675.     set envName "thebibliography"
  1676.     if {$promptNoisily && $useStatusBar} {beep}
  1677.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  1678.     if {$numberItems == "cancel"} then {
  1679.         return
  1680.     } elseif {![isPositiveInteger $numberItems]} then {
  1681.         beep
  1682.         message "invalid input:  unsigned, postive integer required"
  1683.         return
  1684.     }
  1685.     set arg "{9}"
  1686.     if {$numberItems} then {
  1687.         if {$numberItems > 9} then {set arg "{99}"}
  1688.         set body "\t\\bibitem{Ñ}  Ñ"
  1689.         for {set i 1} {$i < $numberItems} {incr i} {
  1690.             append body "\r\r\t\\bibitem{Ñ}  Ñ"
  1691.         }
  1692.         append body "\r"
  1693.     } else {
  1694.         set body "\tÑ\r"
  1695.     }
  1696.     if {[insertEnvironment $envName $arg $body]} then {
  1697.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 {(9)+} [getPos]]
  1698.         eval select $searchResult
  1699.         message "Change the length of the key field?"
  1700.     }
  1701. }
  1702. proc slide {} { doWrapEnvironment "slide" }
  1703. proc overlay {} { doWrapEnvironment "overlay" }
  1704. proc note {} { doWrapEnvironment "note" }
  1705. proc figure {} {
  1706.     global useBoxMacro boxMacroName
  1707.     set envName "figure"
  1708.     set envArg "tbp"
  1709.     set arg "\[$envArg\]"
  1710.     set body ""
  1711.     if {$useBoxMacro} then {
  1712.         append body "\t\\centerline{\\$boxMacroName{Ñ}}\r"
  1713.     }
  1714.     append body "\t\\caption{Ñ}\r"
  1715.     append body "\t\\protect\\label{Ñ}\r"
  1716.     if {$useBoxMacro} then {
  1717.         if {![insertEnvironment $envName $arg $body]} then {return}
  1718.     } else {
  1719.         wrapEnvironment $envName $arg $body
  1720.     }
  1721.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 "$envArg" [getPos]]
  1722.     eval select $searchResult
  1723.     message "Modify this argument?  (t=top; b=bottom; p=page; h=here; !=try harder)"
  1724. }
  1725. proc table {} {
  1726.     set envName "table"
  1727.     set envArg "tbp"
  1728.     # The following statement puts the caption at the top:
  1729.     set arg "\[$envArg\]\r[getIndentation [getPos]]\t\\caption{Ñ}"
  1730.     # The following two statements put the caption at the bottom:
  1731. #     set arg "\[$envArg\]"
  1732. #     set body "\t\\caption{Ñ}\r"
  1733.     append body "\t\\protect\\label{Ñ}\r"
  1734.     wrapEnvironment $envName $arg $body
  1735.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 "$envArg" [getPos]]
  1736.     eval select $searchResult
  1737.     message "Modify this argument?  (t=top; b=bottom; p=page; h=here; !=try harder)"
  1738. }
  1739. proc buildRow {jmax} {
  1740.     set txt "Ñ"
  1741.     for {set j 1} {$j < $jmax} {incr j} {
  1742.         append txt " & Ñ"
  1743.     }
  1744.     return $txt
  1745. }
  1746. proc tabular {} {
  1747.     global promptNoisily useStatusBar
  1748.     set envName "tabular"
  1749.     if {$promptNoisily && $useStatusBar} {beep}
  1750.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  1751.     if {$numberRows == "cancel"} then {
  1752.         return
  1753.     } elseif {![isPositiveInteger $numberRows]} then {
  1754.         beep
  1755.         message "invalid input:  unsigned, postive integer required"
  1756.         return
  1757.     }
  1758.     if {$promptNoisily && $useStatusBar} {beep}
  1759.     catch {sPrompt "$envName:  how many columns?" 3} numberCols
  1760.     if {$numberCols == "cancel"} then {
  1761.         return
  1762.     } elseif {![isPositiveInteger $numberCols]} then {
  1763.         beep
  1764.         message "invalid input:  unsigned, postive integer required"
  1765.         return
  1766.     }
  1767.     set arg "{|"
  1768.     for {set j 1} {$j <= $numberCols} {incr j} {
  1769.         append arg "c|"
  1770.     }
  1771.     append arg "}"
  1772.     set body "\t\\hline\r"
  1773.     for {set i 1} {$i <= $numberRows} {incr i} {
  1774.         append body "\t[buildRow $numberCols]"
  1775.         append body "  \\\\\r\t\\hline\r"
  1776.     }
  1777.     if {[insertEnvironment $envName $arg $body]} then {
  1778.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 {(c|\|)+} [getPos]]
  1779.         select [lindex $searchResult 0] [lindex $searchResult 1]
  1780.         message "Modify this argument?"
  1781.     }
  1782. }
  1783. proc verbatim {} { doWrapEnvironment "verbatim" }
  1784. proc quote {} { doWrapEnvironment "quote" }
  1785. proc quotation {} { doWrapEnvironment "quotation" }
  1786. proc verse {} { doWrapEnvironment "verse" }
  1787. proc flushleft {} { doWrapEnvironment "flushleft" }
  1788. proc center {} { doWrapEnvironment "center" }
  1789. proc flushright {} { doWrapEnvironment "flushright" }
  1790. proc general {} {
  1791.     catch {prompt "What environment?" ""} environmentName
  1792.     if {$environmentName != "cancel"} {
  1793.         doWrapEnvironment "$environmentName"
  1794.     }
  1795. }
  1796.  
  1797. #--------------------------------------------------------------------------
  1798. # Boxes:
  1799. #--------------------------------------------------------------------------
  1800.  
  1801. proc mbox {} {
  1802.     if {[wrapObject "\\mbox{" "}Ñ"]} then {
  1803.         message "mbox set"
  1804.     } else {
  1805.         message "enter text"
  1806.     }
  1807. }
  1808. proc makebox {} {
  1809.     if {[wrapObject "\\makebox\[Ñ\]\[Ñ\]{" "}Ñ"]} then {
  1810.         message "makebox set; enter the width and position"
  1811.     } else {
  1812.         message "enter the width and position of the makebox, then the text"
  1813.     }
  1814. }
  1815. proc fbox {} {
  1816.     if {[wrapObject "\\fbox{" "}Ñ"]} then {
  1817.         message "fbox set"
  1818.     } else {
  1819.         message "enter text"
  1820.     }
  1821. }
  1822. proc framebox {} {
  1823.     if {[wrapObject "\\framebox\[Ñ\]\[Ñ\]{" "}Ñ"]} then {
  1824.         message "framebox set; enter the width and position"
  1825.     } else {
  1826.         message "enter the width and position of the framebox, then the text"
  1827.     }
  1828. }
  1829. proc newsavebox {} {
  1830.     if {[wrapObject "\\newsavebox{" "}Ñ"]} then {
  1831.         message "newsavebox defined"
  1832.     } else {
  1833.         message "enter the command name of the sbox or savebox"
  1834.     }
  1835. }
  1836. proc sbox {} {
  1837.     if {[wrapObject "\\sbox{Ñ}{" "}Ñ"]} then {
  1838.         message "sbox set; enter the command name"
  1839.     } else {
  1840.         message "enter the command name of the sbox, then the text"
  1841.     }
  1842. }
  1843. proc savebox {} {
  1844.     if {[wrapObject "\\savebox{Ñ}\[Ñ\]\[Ñ\]{" "}Ñ"]} then {
  1845.         message "savebox set; enter the command name"
  1846.     } else {
  1847.         message "enter the command name of the savebox"
  1848.     }
  1849. }
  1850. proc usebox {} {
  1851.     if {[wrapObject "\\usebox{" "}Ñ"]} then {
  1852.         message "usebox declared"
  1853.     } else {
  1854.         message "enter the command name of the sbox or savebox"
  1855.     }
  1856. }
  1857. proc raisebox {} {
  1858.     if {[wrapObject "\\raisebox{Ñ}\[Ñ\]\[Ñ\]{" "}Ñ"]} then {
  1859.         message "raisebox set; enter the displacement"
  1860.     } else {
  1861.         message "enter the displacement of the raisebox"
  1862.     }
  1863. }
  1864. proc parbox {} {
  1865.     if {[wrapObject "\\parbox\[Ñ\]\{Ñ\}{" "}Ñ"]} then {
  1866.         message "parbox set; enter the position and width"
  1867.     } else {
  1868.         message "enter the position \[b|c|t\] and width of the parbox, then the text"
  1869.     }
  1870. }
  1871. proc minipage {} {
  1872.     set arg "\[Ñ\]{Ñ}"
  1873.     wrapEnvironment "minipage" $arg ""
  1874.     nextTabStop
  1875.     message "enter the position \[b|c|t\] of the minipage, then the width"
  1876. }
  1877. proc rule {} {
  1878.     insertObject "\\rule\[Ñ\]\{Ñ\}{Ñ}Ñ"
  1879.     nthTabStop -4
  1880.     message "enter the displacement of the rule, then width and height"
  1881. }
  1882.  
  1883. #--------------------------------------------------------------------------
  1884. # Misc:
  1885. #--------------------------------------------------------------------------
  1886.  
  1887. proc ldots {} {insertObject "\\ldots"}
  1888. proc {en-dash} {} {insertObject "--"}
  1889. proc {em-dash} {} {insertObject "---"}
  1890. proc texLogo {} {insertObject "\\TeX"}
  1891. proc latexLogo {} {insertObject "\\LaTeX"}
  1892. proc latex2eLogo {} {insertObject "\\LaTeXe"}
  1893. proc today {} {insertObject "\\today"}
  1894. proc dag {} {insertObject "\\dag"}
  1895. proc ddag {} {insertObject "\\ddag"}
  1896. proc sectionMark {} {insertObject "\\S"}
  1897. proc paragraphMark {} {insertObject "\\P"}
  1898. proc copyright {} {insertObject "\\copyright"}
  1899. proc pounds {} {insertObject "\\pounds"}
  1900. proc quotes {} {
  1901.     if {[wrapObject "`" "'Ñ"]} then {
  1902.         message "text quoted"
  1903.     } else {
  1904.         message "enter text"
  1905.     }
  1906. }
  1907. proc dblQuotes {} {
  1908.     if {[wrapObject "``" "''Ñ"]} then {
  1909.         message "text double quoted"
  1910.     } else {
  1911.         message "enter text"
  1912.     }
  1913. }
  1914. proc marginalNote {} {
  1915.     if {[wrapObject "\\marginpar{" "}Ñ"]} then {
  1916.         message "marginal note set"
  1917.     } else {
  1918.         message "enter marginal note"
  1919.     }
  1920. }
  1921. proc footnote {} {
  1922.     if {[wrapObject "\\footnote{" "}Ñ"]} then {
  1923.         message "footnote set"
  1924.     } else {
  1925.         message "enter footnote"
  1926.     }
  1927. }
  1928. proc label {} {
  1929.     if {[wrapObject "\\label{" "}Ñ"]} then {
  1930.         message "label defined"
  1931.     } else {
  1932.         message "enter label"
  1933.     }
  1934. }
  1935. proc ref {} { 
  1936.     if {[wrapObject "\\ref{" "}Ñ"]} then {
  1937.         message "cross-reference made"
  1938.     } else {
  1939.         message "enter cross-reference"
  1940.     }
  1941. }
  1942. proc pageref {} { 
  1943.     if {[wrapObject "\\pageref{" "}Ñ"]} then {
  1944.         message "page reference made"
  1945.     } else {
  1946.         message "enter page reference"
  1947.     }
  1948. }
  1949. proc cite {} {
  1950.     if {[wrapObject "\\cite{" "}Ñ"]} then {
  1951.         message "citation made"
  1952.     } else {
  1953.         message "enter citation"
  1954.     }
  1955. }
  1956. # Insert an \item or a \bibitem, depending on the context.
  1957. proc insertItem {} {
  1958. #     global TeXmodeVars
  1959. #     if {$TeXmodeVars(expertMode) == 0} then {
  1960. #         if {![isInDocument]} then {
  1961. #             if {$TeXmodeVars(searchNoisily)} {beep}
  1962. #             case [askyesno "The cursor is not in the document environment.\
  1963. #                             \rContinue the operation?"] in {
  1964. #                 "yes" {}
  1965. #                 "no" {error "insertItem:  out of context"}
  1966. #             }
  1967. #         }
  1968. #     }
  1969.     set command [eval getText [searchEnvironment]]
  1970.     set environment [extractCommandArg $command]
  1971.     case $environment in {
  1972.         {itemize enumerate} {
  1973.             set text "\\item  Ñ"
  1974.         }
  1975.         "description" {
  1976.             set text "\\item\[Ñ\]  Ñ"
  1977.         }
  1978.         "thebibliography" {
  1979.             set text "\\bibitem{Ñ}  Ñ"
  1980.         }
  1981.         default {
  1982.             beep
  1983.             message "insertItem: cursor in $environment environment"
  1984.             return
  1985.         }
  1986.     }
  1987.     set pos [getPos]
  1988.     # Indentation should mirror that of an existing \item
  1989.     # (if it exists)
  1990.     insertText [openingCarriageReturn]$text
  1991.     goto $pos
  1992.     nextTabStop
  1993. }
  1994.  
  1995.  
  1996. #############################################################################
  1997. # 
  1998. # Math Mode Macros
  1999. #
  2000. #############################################################################
  2001.  
  2002. #--------------------------------------------------------------------------
  2003. # Math Modes:
  2004. #--------------------------------------------------------------------------
  2005.  
  2006. proc texMath {} {
  2007.     checkMathMode "texMath" 0
  2008.     if {[wrapObject "$" "$Ñ"]} then {
  2009.         message "formula set"
  2010.     } else {
  2011.         message "enter formula"
  2012.     }
  2013. }
  2014. proc texDisplaymath {} {
  2015.     checkMathMode "texDisplaymath" 0
  2016.     if {[wrapObject "$$" "$$Ñ"]} then {
  2017.         message "displayed formula set"
  2018.     } else {
  2019.         message "enter displayed formula"
  2020.     }
  2021. }
  2022. proc latexMath {} {
  2023.     checkMathMode "latexMath" 0
  2024.     if {[wrapObject "\\( " " \\)Ñ"]} then {
  2025.         message "formula set"
  2026.     } else {
  2027.         message "enter formula"
  2028.     }
  2029. }
  2030. proc latexDisplaymath {} {
  2031.     checkMathMode "latexDisplaymath" 0
  2032.     if {[wrapObject "\\\[ " " \\\]Ñ"]} then {
  2033.         message "displayed formula set"
  2034.     } else {
  2035.         message "enter displayed formula"
  2036.     }
  2037. }
  2038.  
  2039. #--------------------------------------------------------------------------
  2040. # Math Style:
  2041. #--------------------------------------------------------------------------
  2042.  
  2043. proc mathit {} {
  2044.     checkMathMode "mathit" 1
  2045.     if {[wrapObject "\\mathit{" "}Ñ"]} then {
  2046.         message "selected text is math italic"
  2047.     } else {
  2048.         message "enter text to be math italic"
  2049.     }
  2050. }
  2051. proc mathrm {} {
  2052.     checkMathMode "mathrm" 1
  2053.     if {[wrapObject "\\mathrm{" "}Ñ"]} then {
  2054.         message "selected text is math roman"
  2055.     } else {
  2056.         message "enter text to be math roman"
  2057.     }
  2058. }
  2059. proc mathbf {} {
  2060.     checkMathMode "mathbf" 1
  2061.     if {[wrapObject "\\mathbf{" "}Ñ"]} then {
  2062.         message "selected text is math bold"
  2063.     } else {
  2064.         message "enter text to be math bold"
  2065.     }
  2066. }
  2067. proc mathsf {} {
  2068.     checkMathMode "mathsf" 1
  2069.     if {[wrapObject "\\mathsf{" "}Ñ"]} then {
  2070.         message "selected text is math sans serif"
  2071.     } else {
  2072.         message "enter text to be math sans serif"
  2073.     }
  2074. }
  2075. proc mathtt {} {
  2076.     checkMathMode "mathtt" 1
  2077.     if {[wrapObject "\\mathtt{" "}Ñ"]} then {
  2078.         message "selected text is math typewriter"
  2079.     } else {
  2080.         message "enter text to be math typewriter"
  2081.     }
  2082. }
  2083. proc mathcal {} {
  2084.     checkMathMode "mathcal" 1
  2085.     # Allow upper-case arguments only:
  2086.     if {[isSelection] && ![isUppercase]} then {
  2087.         alertnote "argument to \\mathcal must be uppercase"
  2088.         return
  2089.     }
  2090.     if {[wrapObject "\\mathcal{" "}Ñ"]} then {
  2091.         message "selected text is calligraphic"
  2092.     } else {
  2093.         message "enter text to be calligraphic (UPPERCASE letters only)"
  2094.     }
  2095. }
  2096. proc displaystyle {} {
  2097.     checkMathMode "displaystyle" 1
  2098.     if {[wrapObject "{\\displaystyle " "}Ñ"]} then {
  2099.         message "displaystyle set"
  2100.     } else {
  2101.         message "enter displaystyle text"
  2102.     }
  2103. }
  2104. proc textstyle {} {
  2105.     checkMathMode "textstyle" 1
  2106.     if {[wrapObject "{\\textstyle " "}Ñ"]} then {
  2107.         message "textstyle set"
  2108.     } else {
  2109.         message "enter textstyle text"
  2110.     }
  2111. }
  2112. proc scriptstyle {} {
  2113.     checkMathMode "scriptstyle" 1
  2114.     if {[wrapObject "{\\scriptstyle " "}Ñ"]} then {
  2115.         message "scriptstyle set"
  2116.     } else {
  2117.         message "enter scriptstyle text"
  2118.     }
  2119. }
  2120. proc scriptscriptstyle {} {
  2121.     checkMathMode "scriptscriptstyle" 1
  2122.     if {[wrapObject "{\\scriptscriptstyle " "}Ñ"]} then {
  2123.         message "scriptscriptstyle set"
  2124.     } else {
  2125.         message "enter scriptscriptstyle text"
  2126.     }
  2127. }
  2128.  
  2129. #--------------------------------------------------------------------------
  2130. # Math Environments:
  2131. #--------------------------------------------------------------------------
  2132.  
  2133. proc math {} { checkMathMode "math" 0; doWrapEnvironment "math" }
  2134. proc displaymath {} {
  2135.     checkMathMode "displaymath" 0
  2136.     doWrapEnvironment "displaymath"
  2137. }
  2138. proc equation {} {
  2139.     checkMathMode "equation" 0
  2140.     set envName "equation"
  2141.     set body "\t\\label{Ñ}\r"
  2142.     if {[wrapEnvironment $envName "" $body]} then {
  2143.         set msgText "equation wrapped"
  2144.     } else {
  2145.         set msgText "enter equation"
  2146.     }
  2147.     nextTabStop
  2148.     message $msgText
  2149. }
  2150. proc eqnarrayStar {} {
  2151.     global promptNoisily useStatusBar
  2152.     checkMathMode "eqnarrayStar" 0
  2153.     set envName "eqnarray*"
  2154.     if {$promptNoisily && $useStatusBar} {beep}
  2155.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  2156.     if {$numberRows == "cancel"} then {
  2157.         return
  2158.     } elseif {![isPositiveInteger $numberRows]} then {
  2159.         beep
  2160.         message "invalid input:  unsigned, postive integer required"
  2161.         return
  2162.     }
  2163.     set row "\t[buildRow 3]"
  2164.     for {set i 1} {$i < $numberRows} {incr i} {
  2165.         append body $row
  2166.         append body "  \\\\\r"
  2167.     }
  2168.     append body $row
  2169.     append body "\r"
  2170.     if {[insertEnvironment $envName "" $body]} then {
  2171.         nextTabStop
  2172.         message "type first item"
  2173.     }
  2174. }
  2175. proc eqnarray {} {
  2176.     global promptNoisily useStatusBar
  2177.     checkMathMode "eqnarray" 0
  2178.     set envName "eqnarray"
  2179.     if {$promptNoisily && $useStatusBar} {beep}
  2180.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  2181.     if {$numberRows == "cancel"} then {
  2182.         return
  2183.     } elseif {![isPositiveInteger $numberRows]} then {
  2184.         beep
  2185.         message "invalid input:  unsigned, postive integer required"
  2186.         return
  2187.     }
  2188.     set row "\t[buildRow 3]\r\t\\label{Ñ}"
  2189.     for {set i 1} {$i < $numberRows} {incr i} {
  2190.         append body $row
  2191.         append body "  \\\\\r"
  2192.     }
  2193.     append body $row
  2194.     append body "\r"
  2195.     if {[insertEnvironment $envName "" $body]} then {
  2196.         nextTabStop
  2197.         message "type first item"
  2198.     }
  2199. }
  2200. proc myArray {} {
  2201.     global promptNoisily useStatusBar
  2202.     checkMathMode "myArray" 1
  2203.     set envName "array"
  2204.     if {$promptNoisily && $useStatusBar} {beep}
  2205.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  2206.     if {$numberRows == "cancel"} then {
  2207.         return
  2208.     } elseif {![isPositiveInteger $numberRows]} then {
  2209.         beep
  2210.         message "invalid input:  unsigned, postive integer required"
  2211.         return
  2212.     }
  2213.     if {$promptNoisily && $useStatusBar} {beep}
  2214.     catch {sPrompt "$envName:  how many columns?" 3} numberCols
  2215.     if {$numberCols == "cancel"} then {
  2216.         return
  2217.     } elseif {![isPositiveInteger $numberCols]} then {
  2218.         beep
  2219.         message "invalid input:  unsigned, postive integer required"
  2220.         return
  2221.     }
  2222.     set arg "{"
  2223.     for {set j 1} {$j <= $numberCols} {incr j} {
  2224.         append arg "c"
  2225.     }
  2226.     append arg "}"
  2227.     set row "\t[buildRow $numberCols]"
  2228.     for {set i 1} {$i < $numberRows} {incr i} {
  2229.         append body $row
  2230.         append body "  \\\\\r"
  2231.     }
  2232.     append body $row
  2233.     append body "\r"
  2234.     if {[insertEnvironment $envName $arg $body]} then {
  2235.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 {c+} [getPos]]
  2236.         select [lindex $searchResult 0] [lindex $searchResult 1]
  2237.         message "Modify this argument?"
  2238.     }
  2239. }
  2240.  
  2241. #--------------------------------------------------------------------------
  2242. # Formulas:
  2243. #--------------------------------------------------------------------------
  2244.  
  2245. proc subscript {} {
  2246.     checkMathMode "subscript" 1
  2247.     if {[wrapObject "_{" "}Ñ"]} then {
  2248.         message "subscript set"
  2249.     } else {
  2250.         message "enter subscript"
  2251.     }
  2252. }
  2253. proc superscript {} {
  2254.     checkMathMode "superscript" 1
  2255.     if {[wrapObject "^{" "}Ñ"]} then {
  2256.         message "superscript set"
  2257.     } else {
  2258.         message "enter superscript"
  2259.     }
  2260. }
  2261. proc fraction {} {
  2262.     checkMathMode "fraction" 1
  2263.     set currentPos [getPos]
  2264.     if {[isSelection]} then {
  2265.         set selection [getSelect]
  2266.         set args [split $selection /]
  2267.         set len [llength $args]
  2268.         deleteText $currentPos [selEnd]
  2269.         if {$len == 1} then {
  2270.             insertObject "\\frac{$selection}{Ñ}Ñ"
  2271.             goto $currentPos
  2272.             nextTabStop
  2273.             message "enter denominator"
  2274.         } else {
  2275.             set firstArg [lindex $args 0]
  2276.             set restArgs [lrange $args 1 [expr $len-1]]
  2277.             insertObject "\\frac{$firstArg}{[join $restArgs /]}"
  2278.             if {$len > 2} {message "beware of multiple /"}
  2279.         }
  2280.     } else {
  2281.         insertObject "\\frac{Ñ}{Ñ}Ñ"
  2282.         goto $currentPos
  2283.         nextTabStop
  2284.         message "enter numerator"
  2285.     }
  2286. }
  2287. proc squareRoot {} {
  2288.     checkMathMode "squareRoot" 1
  2289.     if {[wrapObject "\\sqrt{" "}Ñ"]} then {
  2290.         message "square root set"
  2291.     } else {
  2292.         message "enter formula"
  2293.     }
  2294. }
  2295. proc nthRoot {} {
  2296.     checkMathMode "nthRoot" 1
  2297.     if {[wrapObject "\\sqrt\[Ñ\]{" "}Ñ"]} then {
  2298.         message "enter root"
  2299.     } else {
  2300.         message "enter root, then formula"
  2301.     }
  2302. }
  2303. proc oneParameter {} {
  2304.     checkMathMode "oneParameter" 1
  2305.     catch {prompt "Command name?" "sqrt"} commandName
  2306.     if {$commandName != "cancel"} {wrapObject "\\$commandName{" "}Ñ"}
  2307. }
  2308. proc twoParameters {} {
  2309.     checkMathMode "twoParameters" 1
  2310.     catch {prompt "Command name?" "frac"} commandName
  2311.     if {$commandName != "cancel"} then {
  2312.         set currentPos [getPos]
  2313.         if {[insertObject "\\$commandName{Ñ}{Ñ}Ñ"]} then {
  2314.             goto $currentPos
  2315.             nextTabStop
  2316.         }
  2317.     }
  2318. }
  2319.  
  2320. #--------------------------------------------------------------------------
  2321. # Greek:
  2322. #--------------------------------------------------------------------------
  2323.  
  2324. proc alpha {} {checkMathMode "alpha" 1; insertObject "\\alpha"}
  2325. proc beta {} {checkMathMode "beta" 1; insertObject "\\beta"}
  2326. proc gamma {} {checkMathMode "gamma" 1; insertObject "\\gamma"}
  2327. proc delta {} {checkMathMode "delta" 1; insertObject "\\delta"}
  2328. proc epsilon {} {checkMathMode "epsilon" 1; insertObject "\\epsilon"}
  2329. proc zeta {} {checkMathMode "zeta" 1; insertObject "\\zeta"}
  2330. proc eta {} {checkMathMode "eta" 1; insertObject "\\eta"}
  2331. proc theta {} {checkMathMode "theta" 1; insertObject "\\theta"}
  2332. proc iota {} {checkMathMode "iota" 1; insertObject "\\iota"}
  2333. proc kappa {} {checkMathMode "kappa" 1; insertObject "\\kappa"}
  2334. proc lambda {} {checkMathMode "lambda" 1; insertObject "\\lambda"}
  2335. proc mu {} {checkMathMode "mu" 1; insertObject "\\mu"}
  2336. proc nu {} {checkMathMode "nu" 1; insertObject "\\nu"}
  2337. proc xi {} {checkMathMode "xi" 1; insertObject "\\xi"}
  2338. proc omicron {} {checkMathMode "omicron" 1; insertObject "o"}
  2339. proc pi {} {checkMathMode "pi" 1; insertObject "\\pi"}
  2340. proc rho {} {checkMathMode "rho" 1; insertObject "\\rho"}
  2341. proc sigma {} {checkMathMode "sigma" 1; insertObject "\\sigma"}
  2342. proc tau {} {checkMathMode "tau" 1; insertObject "\\tau"}
  2343. proc upsilon {} {checkMathMode "upsilon" 1; insertObject "\\upsilon"}
  2344. proc phi {} {checkMathMode "phi" 1; insertObject "\\phi"}
  2345. proc chi {} {checkMathMode "chi" 1; insertObject "\\chi"}
  2346. proc psi {} {checkMathMode "psi" 1; insertObject "\\psi"}
  2347. proc omega {} {checkMathMode "omega" 1; insertObject "\\omega"}
  2348.  
  2349. proc Gamma {} {checkMathMode "Gamma" 1; insertObject "\\Gamma"}
  2350. proc Delta {} {checkMathMode "Delta" 1; insertObject "\\Delta"}
  2351. proc Theta {} {checkMathMode "Theta" 1; insertObject "\\Theta"}
  2352. proc Lambda {} {checkMathMode "Lambda" 1; insertObject "\\Lambda"}
  2353. proc Xi {} {checkMathMode "Xi" 1; insertObject "\\Xi"}
  2354. proc Pi {} {checkMathMode "Pi" 1; insertObject "\\Pi"}
  2355. proc Sigma {} {checkMathMode "Sigma" 1; insertObject "\\Sigma"}
  2356. proc Upsilon {} {checkMathMode "Upsilon" 1; insertObject "\\Upsilon"}
  2357. proc Phi {} {checkMathMode "Phi" 1; insertObject "\\Phi"}
  2358. proc Psi {} {checkMathMode "Psi" 1; insertObject "\\Psi"}
  2359. proc Omega {} {checkMathMode "Omega" 1; insertObject "\\Omega"}
  2360.  
  2361. proc varepsilon {} {checkMathMode "varepsilon" 1; insertObject "\\varepsilon"}
  2362. proc vartheta {} {checkMathMode "vartheta" 1; insertObject "\\vartheta"}
  2363. proc varpi {} {checkMathMode "varpi" 1; insertObject "\\varpi"}
  2364. proc varrho {} {checkMathMode "varrho" 1; insertObject "\\varrho"}
  2365. proc varsigma {} {checkMathMode "varsigma" 1; insertObject "\\varsigma"}
  2366. proc varphi {} {checkMathMode "varphi" 1; insertObject "\\varphi"}
  2367.  
  2368. #--------------------------------------------------------------------------
  2369. # Binary Ops:
  2370. #--------------------------------------------------------------------------
  2371.  
  2372. proc pm {} {checkMathMode "pm" 1; insertObject "\\pm"}
  2373. proc mp {} {checkMathMode "mp" 1; insertObject "\\mp"}
  2374. proc times {} {checkMathMode "times" 1; insertObject "\\times"}
  2375. proc div {} {checkMathMode "div" 1; insertObject "\\div"}
  2376. proc ast {} {checkMathMode "ast" 1; insertObject "\\ast"}
  2377. proc star {} {checkMathMode "star" 1; insertObject "\\star"}
  2378. proc circ {} {checkMathMode "circ" 1; insertObject "\\circ"}
  2379. proc bullet {} {checkMathMode "bullet" 1; insertObject "\\bullet"}
  2380. proc cdot {} {checkMathMode "cdot" 1; insertObject "\\cdot"}
  2381. proc cap {} {checkMathMode "cap" 1; insertObject "\\cap"}
  2382. proc cup {} {checkMathMode "cup" 1; insertObject "\\cup"}
  2383. proc uplus {} {checkMathMode "uplus" 1; insertObject "\\uplus"}
  2384. proc sqcap {} {checkMathMode "sqcap" 1; insertObject "\\sqcap"}
  2385. proc sqcup {} {checkMathMode "sqcup" 1; insertObject "\\sqcup"}
  2386. proc vee {} {checkMathMode "vee" 1; insertObject "\\vee"}
  2387. proc wedge {} {checkMathMode "wedge" 1; insertObject "\\wedge"}
  2388. proc setminus {} {checkMathMode "setminus" 1; insertObject "\\setminus"}
  2389. proc wr {} {checkMathMode "wr" 1; insertObject "\\wr"}
  2390. proc diamond {} {checkMathMode "diamond" 1; insertObject "\\diamond"}
  2391. proc bigtriangleup {} {
  2392.     checkMathMode "bigtriangleup" 1; insertObject "\\bigtriangleup"
  2393. }
  2394. proc bigtriangledown {} {
  2395.     checkMathMode "bigtriangledown" 1; insertObject "\\bigtriangledown"
  2396. }
  2397. proc triangleleft {} {
  2398.     checkMathMode "triangleleft" 1; insertObject "\\triangleleft"
  2399. }
  2400. proc triangleright {} {
  2401.     checkMathMode "triangleright" 1; insertObject "\\triangleright"
  2402. }
  2403. proc lhd {} {
  2404.     if {[isSymbolPackageLoaded]} then {
  2405.         checkMathMode "lhd" 1; insertObject "\\lhd"
  2406.     }
  2407. }
  2408. proc rhd {} {
  2409.     if {[isSymbolPackageLoaded]} then {
  2410.         checkMathMode "rhd" 1; insertObject "\\rhd"
  2411.     }
  2412. }
  2413. proc unlhd {} {
  2414.     if {[isSymbolPackageLoaded]} then {
  2415.         checkMathMode "unlhd" 1; insertObject "\\unlhd"
  2416.     }
  2417. }
  2418. proc unrhd {} {
  2419.     if {[isSymbolPackageLoaded]} then {
  2420.         checkMathMode "unrhd" 1; insertObject "\\unrhd"
  2421.     }
  2422. }
  2423. proc oplus {} {checkMathMode "oplus" 1; insertObject "\\oplus"}
  2424. proc ominus {} {checkMathMode "ominus" 1; insertObject "\\ominus"}
  2425. proc otimes {} {checkMathMode "otimes" 1; insertObject "\\otimes"}
  2426. proc oslash {} {checkMathMode "oslash" 1; insertObject "\\oslash"}
  2427. proc odot {} {checkMathMode "odot" 1; insertObject "\\odot"}
  2428. proc bigcirc {} {checkMathMode "bigcirc" 1; insertObject "\\bigcirc"}
  2429. proc dagger {} {checkMathMode "dagger" 1; insertObject "\\dagger"}
  2430. proc ddagger {} {checkMathMode "ddagger" 1; insertObject "\\ddagger"}
  2431. proc amalg {} {checkMathMode "amalg" 1; insertObject "\\amalg"}
  2432.  
  2433. #--------------------------------------------------------------------------
  2434. # Relations:
  2435. #--------------------------------------------------------------------------
  2436.  
  2437. proc leq {} {checkMathMode "leq" 1; insertObject "\\leq"}
  2438. proc prec {} {checkMathMode "prec" 1; insertObject "\\prec"}
  2439. proc preceq {} {checkMathMode "preceq" 1; insertObject "\\preceq"}
  2440. proc myLl {} {checkMathMode "myLl" 1; insertObject "\\ll"}
  2441. proc subset {} {checkMathMode "subset" 1; insertObject "\\subset"}
  2442. proc subseteq {} {checkMathMode "subseteq" 1; insertObject "\\subseteq"}
  2443. proc sqsubset {} {
  2444.     if {[isSymbolPackageLoaded]} then {
  2445.         checkMathMode "sqsubset" 1; insertObject "\\sqsubset"
  2446.     }
  2447. }
  2448. proc sqsubseteq {} {checkMathMode "sqsubseteq" 1; insertObject "\\sqsubseteq"}
  2449. proc in {} {checkMathMode "in" 1; insertObject "\\in"}
  2450. proc vdash {} {checkMathMode "vdash" 1; insertObject "\\vdash"}
  2451.  
  2452. proc geq {} {checkMathMode "geq" 1; insertObject "\\geq"}
  2453. proc succ {} {checkMathMode "succ" 1; insertObject "\\succ"}
  2454. proc succeq {} {checkMathMode "succeq" 1; insertObject "\\succeq"}
  2455. proc gg {} {checkMathMode "gg" 1; insertObject "\\gg"}
  2456. proc supset {} {checkMathMode "supset" 1; insertObject "\\supset"}
  2457. proc supseteq {} {checkMathMode "supseteq" 1; insertObject "\\supseteq"}
  2458. proc sqsupset {} {
  2459.     if {[isSymbolPackageLoaded]} then {
  2460.         checkMathMode "sqsupset" 1; insertObject "\\sqsupset"
  2461.     }
  2462. }
  2463. proc sqsupseteq {} {checkMathMode "sqsupseteq" 1; insertObject "\\sqsupseteq"}
  2464. proc ni {} {checkMathMode "ni" 1; insertObject "\\ni"}
  2465. proc dashv {} {checkMathMode "dashv" 1; insertObject "\\dashv"}
  2466.  
  2467. proc equiv {} {checkMathMode "equiv" 1; insertObject "\\equiv"}
  2468. proc sim {} {checkMathMode "sim" 1; insertObject "\\sim"}
  2469. proc simeq {} {checkMathMode "simeq" 1; insertObject "\\simeq"}
  2470. proc asymp {} {checkMathMode "asymp" 1; insertObject "\\asymp"}
  2471. proc approx {} {checkMathMode "approx" 1; insertObject "\\approx"}
  2472. proc cong {} {checkMathMode "cong" 1; insertObject "\\cong"}
  2473. proc neq {} {checkMathMode "neq" 1; insertObject "\\neq"}
  2474. proc doteq {} {checkMathMode "doteq" 1; insertObject "\\doteq"}
  2475. proc propto {} {checkMathMode "propto" 1; insertObject "\\propto"}
  2476.  
  2477. proc models {} {checkMathMode "models" 1; insertObject "\\models"}
  2478. proc perp {} {checkMathMode "perp" 1; insertObject "\\perp"}
  2479. proc mid {} {checkMathMode "mid" 1; insertObject "\\mid"}
  2480. proc parallel {} {checkMathMode "parallel" 1; insertObject "\\parallel"}
  2481. proc bowtie {} {checkMathMode "bowtie" 1; insertObject "\\bowtie"}
  2482. proc myJoin {} {
  2483.     if {[isSymbolPackageLoaded]} then {
  2484.         checkMathMode "myJoin" 1; insertObject "\\join"
  2485.     }
  2486. }
  2487. proc smile {} {checkMathMode "smile" 1; insertObject "\\smile"}
  2488. proc frown {} {checkMathMode "frown" 1; insertObject "\\frown"}
  2489.  
  2490. #--------------------------------------------------------------------------
  2491. # Arrows:
  2492. #--------------------------------------------------------------------------
  2493.  
  2494. proc leftarrow {} {checkMathMode "leftarrow" 1; insertObject "\\leftarrow"}
  2495. proc Leftarrow {} {checkMathMode "Leftarrow" 1; insertObject "\\Leftarrow"}
  2496. proc rightarrow {} {checkMathMode "rightarrow" 1; insertObject "\\rightarrow"}
  2497. proc Rightarrow {} {checkMathMode "Rightarrow" 1; insertObject "\\Rightarrow"}
  2498. proc leftrightarrow {} {
  2499.     checkMathMode "leftrightarrow" 1; insertObject "\\leftrightarrow"
  2500. }
  2501. proc Leftrightarrow {} {
  2502.     checkMathMode "Leftrightarrow" 1; insertObject "\\Leftrightarrow"
  2503. }
  2504. proc mapsto {} {checkMathMode "mapsto" 1; insertObject "\\mapsto"}
  2505. proc hookleftarrow {} {
  2506.     checkMathMode "hookleftarrow" 1; insertObject "\\hookleftarrow"
  2507. }
  2508. proc leftharpoonup {} {
  2509.     checkMathMode "leftharpoonup" 1; insertObject "\\leftharpoonup"
  2510. }
  2511. proc leftharpoondown {} {
  2512.     checkMathMode "leftharpoondown" 1; insertObject "\\leftharpoondown"
  2513. }
  2514. proc rightleftharpoons {} {
  2515.     checkMathMode "rightleftharpoons" 1; insertObject "\\rightleftharpoons"
  2516. }
  2517.  
  2518. proc longleftarrow {} {
  2519.     checkMathMode "longleftarrow" 1; insertObject "\\longleftarrow"
  2520. }
  2521. proc Longleftarrow {} {
  2522.     checkMathMode "Longleftarrow" 1; insertObject "\\Longleftarrow"
  2523. }
  2524. proc longrightarrow {} {
  2525.     checkMathMode "longrightarrow" 1; insertObject "\\longrightarrow"
  2526. }
  2527. proc Longrightarrow {} {
  2528.     checkMathMode "Longrightarrow" 1; insertObject "\\Longrightarrow"
  2529. }
  2530. proc longleftrightarrow {} {
  2531.     checkMathMode "longleftrightarrow" 1; insertObject "\\longleftrightarrow"
  2532. }
  2533. proc Longleftrightarrow {} {
  2534.     checkMathMode "Longleftrightarrow" 1; insertObject "\\Longleftrightarrow"
  2535. }
  2536. proc longmapsto {} {checkMathMode "longmapsto" 1; insertObject "\\longmapsto"}
  2537. proc hookrightarrow {} {
  2538.     checkMathMode "hookrightarrow" 1; insertObject "\\hookrightarrow"
  2539. }
  2540. proc rightharpoonup {} {
  2541.     checkMathMode "rightharpoonup" 1; insertObject "\\rightharpoonup"
  2542. }
  2543. proc rightharpoondown {} {
  2544.     checkMathMode "rightharpoondown" 1; insertObject "\\rightharpoondown"
  2545. }
  2546. proc leadsto {} {
  2547.     if {[isSymbolPackageLoaded]} then {
  2548.         checkMathMode "leadsto" 1; insertObject "\\leadsto"
  2549.     }
  2550. }
  2551. proc uparrow {} {checkMathMode "uparrow" 1; insertObject "\\uparrow"}
  2552. proc Uparrow {} {checkMathMode "Uparrow" 1; insertObject "\\Uparrow"}
  2553. proc downarrow {} {checkMathMode "downarrow" 1; insertObject "\\downarrow"}
  2554. proc Downarrow {} {checkMathMode "Downarrow" 1; insertObject "\\Downarrow"}
  2555. proc updownarrow {} {checkMathMode "updownarrow" 1; insertObject "\\updownarrow"}
  2556. proc Updownarrow {} {checkMathMode "Updownarrow" 1; insertObject "\\Updownarrow"}
  2557. proc nearrow {} {checkMathMode "nearrow" 1; insertObject "\\nearrow"}
  2558. proc searrow {} {checkMathMode "searrow" 1; insertObject "\\searrow"}
  2559. proc swarrow {} {checkMathMode "swarrow" 1; insertObject "\\swarrow"}
  2560. proc nwarrow {} {checkMathMode "nwarrow" 1; insertObject "\\nwarrow"}
  2561.  
  2562. #--------------------------------------------------------------------------
  2563. # Dots:
  2564. #--------------------------------------------------------------------------
  2565.  
  2566. proc cdots {} {checkMathMode "cdots" 1; insertObject "\\cdots"}
  2567. proc vdots {} {checkMathMode "vdots" 1; insertObject "\\vdots"}
  2568. proc ddots {} {checkMathMode "ddots" 1; insertObject "\\ddots"}
  2569.  
  2570. #--------------------------------------------------------------------------
  2571. # Symbols:
  2572. #--------------------------------------------------------------------------
  2573.  
  2574. proc aleph {} {checkMathMode "aleph" 1; insertObject "\\aleph"}
  2575. proc hbar {} {checkMathMode "hbar" 1; insertObject "\\hbar"}
  2576. proc imath {} {checkMathMode "imath" 1; insertObject "\\imath"}
  2577. proc jmath {} {checkMathMode "jmath" 1; insertObject "\\jmath"}
  2578. proc ell {} {checkMathMode "ell" 1; insertObject "\\ell"}
  2579. proc wp {} {checkMathMode "wp" 1; insertObject "\\wp"}
  2580. proc Re {} {checkMathMode "Re" 1; insertObject "\\Re"}
  2581. proc Im {} {checkMathMode "Im" 1; insertObject "\\Im"}
  2582. proc mho {} {
  2583.     if {[isSymbolPackageLoaded]} then {
  2584.         checkMathMode "mho" 1; insertObject "\\mho"
  2585.     }
  2586. }
  2587. proc prime {} {checkMathMode "prime" 1; insertObject "\\prime"}
  2588. proc emptyset {} {checkMathMode "emptyset" 1; insertObject "\\emptyset"}
  2589. proc nabla {} {checkMathMode "nabla" 1; insertObject "\\nabla"}
  2590. proc surd {} {checkMathMode "surd" 1; insertObject "\\surd"}
  2591. proc top {} {checkMathMode "top" 1; insertObject "\\top"}
  2592. proc bot {} {checkMathMode "bot" 1; insertObject "\\bot"}
  2593. # proc | {} {checkMathMode "|" 1; insertObject "\\|"}
  2594. proc angle {} {checkMathMode "angle" 1; insertObject "\\angle"}
  2595. proc forall {} {checkMathMode "forall" 1; insertObject "\\forall"}
  2596. proc exists {} {checkMathMode "exists" 1; insertObject "\\exists"}
  2597. proc neg {} {checkMathMode "neg" 1; insertObject "\\neg"}
  2598. proc flat {} {checkMathMode "flat" 1; insertObject "\\flat"}
  2599. proc natural {} {checkMathMode "natural" 1; insertObject "\\natural"}
  2600. proc sharp {} {checkMathMode "sharp" 1; insertObject "\\sharp"}
  2601. proc backslash {} {checkMathMode "backslash" 1; insertObject "\\backslash"}
  2602. proc partial {} {checkMathMode "partial" 1; insertObject "\\partial"}
  2603. proc infty {} {checkMathMode "infty" 1; insertObject "\\infty"}
  2604. proc Box {} {
  2605.     if {[isSymbolPackageLoaded]} then {
  2606.         checkMathMode "Box" 1; insertObject "\\Box"
  2607.     }
  2608. }
  2609. proc Diamond {} {
  2610.     if {[isSymbolPackageLoaded]} then {
  2611.         checkMathMode "Diamond" 1; insertObject "\\Diamond"
  2612.     }
  2613. }
  2614. proc triangle {} {checkMathMode "triangle" 1; insertObject "\\triangle"}
  2615. proc clubsuit {} {checkMathMode "clubsuit" 1; insertObject "\\clubsuit"}
  2616. proc diamondsuit {} {checkMathMode "diamondsuit" 1; insertObject "\\diamondsuit"}
  2617. proc heartsuit {} {checkMathMode "heartsuit" 1; insertObject "\\heartsuit"}
  2618. proc spadesuit {} {checkMathMode "spadesuit" 1; insertObject "\\spadesuit"}
  2619.  
  2620. #--------------------------------------------------------------------------
  2621. # Functions:
  2622. #--------------------------------------------------------------------------
  2623.  
  2624. proc arccos {} {checkMathMode "arccos" 1; insertObject "\\arccos"}
  2625. proc arcsin {} {checkMathMode "arcsin" 1; insertObject "\\arcsin"}
  2626. proc arctan {} {checkMathMode "arctan" 1; insertObject "\\arctan"}
  2627. proc arg {} {checkMathMode "arg" 1; insertObject "\\arg"}
  2628. proc cos {} {checkMathMode "cos" 1; insertObject "\\cos"}
  2629. proc cosh {} {checkMathMode "cosh" 1; insertObject "\\cosh"}
  2630. proc cot {} {checkMathMode "cot" 1; insertObject "\\cot"}
  2631. proc coth {} {checkMathMode "coth" 1; insertObject "\\coth"}
  2632. proc csc {} {checkMathMode "csc" 1; insertObject "\\csc"}
  2633. proc deg {} {checkMathMode "deg" 1; insertObject "\\deg"}
  2634. proc det {} {checkMathMode "det" 1; insertObject "\\det"}
  2635. proc dim {} {checkMathMode "dim" 1; insertObject "\\dim"}
  2636. proc exp {} {checkMathMode "exp" 1; insertObject "\\exp"}
  2637. proc gcd {} {checkMathMode "gcd" 1; insertObject "\\gcd"}
  2638. proc hom {} {checkMathMode "hom" 1; insertObject "\\hom"}
  2639. proc inf {} {checkMathMode "inf" 1; insertObject "\\inf"}
  2640. proc ker {} {checkMathMode "ker" 1; insertObject "\\ker"}
  2641. proc lg {} {checkMathMode "lg" 1; insertObject "\\lg"}
  2642. proc lim {} {checkMathMode "lim" 1; insertObject "\\lim"}
  2643. proc liminf {} {checkMathMode "liminf" 1; insertObject "\\liminf"}
  2644. proc limsup {} {checkMathMode "limsup" 1; insertObject "\\limsup"}
  2645. proc ln {} {checkMathMode "ln" 1; insertObject "\\ln"}
  2646. proc log {} {checkMathMode "log" 1; insertObject "\\log"}
  2647. proc max {} {checkMathMode "max" 1; insertObject "\\max"}
  2648. proc min {} {checkMathMode "min" 1; insertObject "\\min"}
  2649. proc Pr {} {checkMathMode "Pr" 1; insertObject "\\Pr"}
  2650. proc sec {} {checkMathMode "sec" 1; insertObject "\\sec"}
  2651. proc sin {} {checkMathMode "sin" 1; insertObject "\\sin"}
  2652. proc sinh {} {checkMathMode "sinh" 1; insertObject "\\sinh"}
  2653. proc sup {} {checkMathMode "sup" 1; insertObject "\\sup"}
  2654. proc tan {} {checkMathMode "tan" 1; insertObject "\\tan"}
  2655. proc tanh {} {checkMathMode "tanh" 1; insertObject "\\tanh"}
  2656.  
  2657. proc bmod {} {checkMathMode "bmod" 1; insertObject "\\bmod"}
  2658. proc pmod {} {
  2659.     checkMathMode "pmod" 1
  2660.     if {[wrapObject "\\pmod{" "}Ñ"]} then {
  2661.         message "parenthesized mod set"
  2662.     } else {
  2663.         message "enter formula"
  2664.     }
  2665. }
  2666.  
  2667. #--------------------------------------------------------------------------
  2668. # Large Ops:
  2669. #--------------------------------------------------------------------------
  2670.  
  2671. proc insertLargeOp {commandName} {
  2672.     checkMathMode "$commandName" 1
  2673.     set currentPos [getPos]
  2674.     insertObject "\\$commandName\_{Ñ}^{Ñ}Ñ"
  2675.     goto $currentPos
  2676.     nextTabStop
  2677. }
  2678. proc sum {} {insertLargeOp "sum"}
  2679. proc prod {} {insertLargeOp "prod"}
  2680. proc coprod {} {insertLargeOp "coprod"}
  2681. proc int {} {insertLargeOp "int"}
  2682. proc oint {} {insertLargeOp "oint"}
  2683. proc bigcap {} {insertLargeOp "bigcap"}
  2684. proc bigcup {} {insertLargeOp "bigcup"}
  2685. proc bigsqcup {} {insertLargeOp "bigsqcup"}
  2686. proc bigvee {} {insertLargeOp "bigvee"}
  2687. proc bigwedge {} {insertLargeOp "bigwedge"}
  2688. proc bigodot {} {insertLargeOp "bigodot"}
  2689. proc bigotimes {} {insertLargeOp "bigotimes"}
  2690. proc bigoplus {} {insertLargeOp "bigoplus"}
  2691. proc biguplus {} {insertLargeOp "biguplus"}
  2692.  
  2693. #--------------------------------------------------------------------------
  2694. # Delimiters:
  2695. #--------------------------------------------------------------------------
  2696.  
  2697. proc delimitObject {leftDelim rightDelim} {
  2698.     if {[wrapObject $leftDelim $rightDelim]} then {
  2699.         message "formula delimited"
  2700.     } else {
  2701.         message "enter formula"
  2702.     }
  2703. }
  2704. proc parentheses {} { checkMathMode "parentheses" 1; delimitObject "(" ")Ñ" }
  2705. proc brackets {} { checkMathMode "brackets" 1; delimitObject "\[" "\]Ñ" }
  2706. proc braces {} { checkMathMode "braces" 1; delimitObject "\\\{" "\\\}Ñ" }
  2707. proc absoluteValue {} { checkMathMode "absoluteValue" 1; delimitObject "|" "|Ñ" }
  2708. proc getDelims {} {
  2709.     catch {prompt "Choose delimiters:" "parentheses" "" "parentheses" \
  2710.                   "brackets" "braces" "angle brackets" "vertical bars" \
  2711.                   "double bars" "ceiling" "floor"} delimType
  2712.     if {$delimType != "cancel"} then {
  2713.         case $delimType in {
  2714.             "parentheses" {
  2715.                 set leftDelim "("
  2716.                 set rightDelim ")"
  2717.             }
  2718.             "brackets" {
  2719.                 set leftDelim "\["
  2720.                 set rightDelim "\]"
  2721.             }
  2722.             "braces" {
  2723.                 set leftDelim "\\\{"
  2724.                 set rightDelim "\\\}"
  2725.             }
  2726.             "{vertical bars}" {
  2727.                 set leftDelim "|"
  2728.                 set rightDelim "|"
  2729.             }
  2730.             "{double bars}" {
  2731.                 set leftDelim "\\|"
  2732.                 set rightDelim "\\|"
  2733.             }
  2734.             "{angle brackets}" {
  2735.                 set leftDelim "\\langle"
  2736.                 set rightDelim "\\rangle"
  2737.             }
  2738.             "ceiling" {
  2739.                 set leftDelim "\\lceil"
  2740.                 set rightDelim "\\rceil"
  2741.             }
  2742.             "floor" {
  2743.                 set leftDelim "\\lfloor"
  2744.                 set rightDelim "\\rfloor"
  2745.             }
  2746.             default {
  2747.                 alertnote "\"$delimType\" not recognized"
  2748.                 return ""
  2749.             }
  2750.         }
  2751.         return [list $leftDelim $rightDelim]
  2752.     } else {return ""}
  2753. }
  2754. proc otherDelims {} {
  2755.     checkMathMode "otherDelims" 1
  2756.     set delims [getDelims]
  2757.     if {$delims != ""} then {
  2758.         set leftDelim [lindex $delims 0]
  2759.         set rightDelim [lindex $delims 1]
  2760.         delimitObject "$leftDelim" "$rightDelimÑ"
  2761.     }
  2762. }
  2763. proc {half-openInterval} {} {
  2764.     checkMathMode "half-openInterval" 1; delimitObject "(" "\]Ñ"
  2765. }
  2766. proc {half-closedInterval} {} {
  2767.     checkMathMode "half-closedInterval" 1; delimitObject "\[" ")Ñ"
  2768. }
  2769.  
  2770. proc insertBigDelims {leftDelim rightDelim isMultiline} {
  2771.     checkMathMode "insertBigDelims" 1
  2772.     if {$isMultiline} then {
  2773.         alertnote "Multi-line delimiters not yet implemented."
  2774.     } else {
  2775.         if {[wrapObject $leftDelim $rightDelim]} then {
  2776.             message "formula delimited"
  2777.         } else {
  2778.             message "enter formula"
  2779.         }
  2780.     }
  2781. }
  2782. proc bigParentheses {} {
  2783.     checkMathMode "bigParentheses" 1; insertBigDelims "\\left(" "\\right)Ñ" 0
  2784. }
  2785. proc bigBrackets {} {
  2786.     checkMathMode "bigBrackets" 1; insertBigDelims "\\left\[" "\\right\]Ñ" 0
  2787. }
  2788. proc bigBraces {} {
  2789.     checkMathMode "bigBraces" 1; insertBigDelims "\\left\\\{" "\\right\\\}Ñ" 0
  2790. }
  2791. proc bigAbsoluteValue {} {
  2792.     checkMathMode "bigAbsoluteValue" 1; insertBigDelims "\\left|" "\\right|Ñ" 0
  2793. }
  2794. proc otherBigDelims {} {
  2795.     checkMathMode "otherBigDelims" 1
  2796.     set delims [getDelims]
  2797.     if {$delims != ""} then {
  2798.         append leftDelim "\\left" [lindex $delims 0]
  2799.         append rightDelim "\\right" [lindex $delims 1]
  2800.         insertBigDelims "$leftDelim" "$rightDelimÑ" 0
  2801.     }
  2802. }
  2803. proc bigLeftBrace {} { checkMathMode "bigLeftBrace" 1; insertBigDelims "\\left\\\{" "\\right.Ñ" 0 }
  2804. proc otherMixedBigDelims {} {
  2805.     checkMathMode "otherMixedBigDelims" 1
  2806.     catch {prompt "Choose LEFT delimiter:" "parenthesis" "" "parenthesis" \
  2807.                   "bracket" "brace" "vertical bar" "double bar" \
  2808.                   "angle bracket" "ceiling" "floor" "slash" "backslash" \
  2809.                   "none"} delimType
  2810.     if {$delimType != "cancel"} then {
  2811.         case $delimType in {
  2812.             "parenthesis" {set leftDelim "("}
  2813.             "bracket" {set leftDelim "\["}
  2814.             "brace" {set leftDelim "\\\{"}
  2815.             "{vertical bar}" {set leftDelim "|"}
  2816.             "{double bar}" {set leftDelim "\\|"}
  2817.             "{angle bracket}" {set leftDelim "\\langle"}
  2818.             "ceiling" {set leftDelim "\\lceil"}
  2819.             "floor" {set leftDelim "\\lfloor"}
  2820.             "slash" {set leftDelim "/"}
  2821.             "backslash" {set leftDelim "\\backslash"}
  2822.             "none" {set leftDelim "."}
  2823.             default {
  2824.                 alertnote "\"$delimType\" not recognized"
  2825.                 return
  2826.             }
  2827.         }
  2828.         catch {prompt "Choose RIGHT delimiter:" "parenthesis" "" "parenthesis" \
  2829.                       "bracket" "brace" "vertical bar" "double bar" \
  2830.                       "angle bracket" "ceiling" "floor" "slash" "backslash" \
  2831.                       "none"} delimType
  2832.         if {$delimType != "cancel"} then {
  2833.             case $delimType in {
  2834.                 "parenthesis" {set rightDelim ")"}
  2835.                 "bracket" {set rightDelim "\]"}
  2836.                 "brace" {set rightDelim "\\\}"}
  2837.                 "{vertical bar}" {set rightDelim "|"}
  2838.                 "{double bar}" {set rightDelim "\\|"}
  2839.                 "{angle bracket}" {set rightDelim "\\rangle"}
  2840.                 "ceiling" {set rightDelim "\\rceil"}
  2841.                 "floor" {set rightDelim "\\rfloor"}
  2842.                 "slash" {set rightDelim "/"}
  2843.                 "backslash" {set rightDelim "\\backslash"}
  2844.                 "none" {set rightDelim "."}
  2845.                 default {
  2846.                     alertnote "\"$delimType\" not recognized"
  2847.                     return
  2848.                 }
  2849.             }
  2850.             insertBigDelims "\\left$leftDelim" "\\right$rightDelimÑ" 0
  2851.         }
  2852.     }
  2853. }
  2854.  
  2855. #--------------------------------------------------------------------------
  2856. # Accents:
  2857. #--------------------------------------------------------------------------
  2858.  
  2859. proc acute {} {
  2860.     checkMathMode "acute" 1
  2861.     if {[isSelection] > 1} then {
  2862.         alertnote "Warning: only a single character may be accented!"
  2863.     }
  2864.     if {[wrapObject "\\acute{" "}Ñ"]} then {
  2865.         message "accent set"
  2866.     } else {
  2867.         message "enter one character"
  2868.     }
  2869. }
  2870. proc bar {} {
  2871.     checkMathMode "bar" 1
  2872.     if {[isSelection] > 1} then {
  2873.         alertnote "Warning: only a single character may be accented!"
  2874.     }
  2875.     if {[wrapObject "\\bar{" "}Ñ"]} then {
  2876.         message "accent set"
  2877.     } else {
  2878.         message "enter one character"
  2879.     }
  2880. }
  2881. proc breve {} {
  2882.     checkMathMode "breve" 1
  2883.     if {[isSelection] > 1} then {
  2884.         alertnote "Warning: only a single character may be accented!"
  2885.     }
  2886.     if {[wrapObject "\\breve{" "}Ñ"]} then {
  2887.         message "accent set"
  2888.     } else {
  2889.         message "enter one character"
  2890.     }
  2891. }
  2892. proc check {} {
  2893.     checkMathMode "check" 1
  2894.     if {[isSelection] > 1} then {
  2895.         alertnote "Warning: only a single character may be accented!"
  2896.     }
  2897.     if {[wrapObject "\\check{" "}Ñ"]} then {
  2898.         message "accent set"
  2899.     } else {
  2900.         message "enter one character"
  2901.     }
  2902. }
  2903. proc dot {} {
  2904.     checkMathMode "dot" 1
  2905.     if {[isSelection] > 1} then {
  2906.         alertnote "Warning: only a single character may be accented!"
  2907.     }
  2908.     if {[wrapObject "\\dot{" "}Ñ"]} then {
  2909.         message "accent set"
  2910.     } else {
  2911.         message "enter one character"
  2912.     }
  2913. }
  2914. proc ddot {} {
  2915.     checkMathMode "ddot" 1
  2916.     if {[isSelection] > 1} then {
  2917.         alertnote "Warning: only a single character may be accented!"
  2918.     }
  2919.     if {[wrapObject "\\ddot{" "}Ñ"]} then {
  2920.         message "accent set"
  2921.     } else {
  2922.         message "enter one character"
  2923.     }
  2924. }
  2925. proc grave {} {
  2926.     checkMathMode "grave" 1
  2927.     if {[isSelection] > 1} then {
  2928.         alertnote "Warning: only a single character may be accented!"
  2929.     }
  2930.     if {[wrapObject "\\grave{" "}Ñ"]} then {
  2931.         message "accent set"
  2932.     } else {
  2933.         message "enter one character"
  2934.     }
  2935. }
  2936. proc hat {} {
  2937.     checkMathMode "hat" 1
  2938.     if {[isSelection] > 1} then {
  2939.         alertnote "Warning: only a single character may be accented!"
  2940.     }
  2941.     if {[wrapObject "\\hat{" "}Ñ"]} then {
  2942.         message "accent set"
  2943.     } else {
  2944.         message "enter one character"
  2945.     }
  2946. }
  2947. proc tilde {} {
  2948.     checkMathMode "tilde" 1
  2949.     if {[isSelection] > 1} then {
  2950.         alertnote "Warning: only a single character may be accented!"
  2951.     }
  2952.     if {[wrapObject "\\tilde{" "}Ñ"]} then {
  2953.         message "accent set"
  2954.     } else {
  2955.         message "enter one character"
  2956.     }
  2957. }
  2958. proc vec {} {
  2959.     checkMathMode "vec" 1
  2960.     if {[isSelection] > 1} then {
  2961.         alertnote "Warning: only a single character may be accented!"
  2962.     }
  2963.     if {[wrapObject "\\vec{" "}Ñ"]} then {
  2964.         message "accent set"
  2965.     } else {
  2966.         message "enter one character"
  2967.     }
  2968. }
  2969.  
  2970. proc widehat {} {
  2971.     checkMathMode "widehat" 1
  2972.     if {[isSelection] > 3} then {
  2973.         alertnote "Warning: only a few characters may be accented!"
  2974.     }
  2975.     if {[wrapObject "\\widehat{" "}Ñ"]} then {
  2976.         message "accent set"
  2977.     } else {
  2978.         message "enter a few characters"
  2979.     }
  2980. }
  2981. proc widetilde {} {
  2982.     checkMathMode "widetilde" 1
  2983.     if {[isSelection] > 3} then {
  2984.         alertnote "Warning: only a few characters may be accented!"
  2985.     }
  2986.     if {[wrapObject "\\widetilde{" "}Ñ"]} then {
  2987.         message "accent set"
  2988.     } else {
  2989.         message "enter a few characters"
  2990.     }
  2991. }
  2992.  
  2993. proc imath {} {checkMathMode "imath" 1; insertObject "\\imath"}
  2994. proc jmath {} {checkMathMode "jmath" 1; insertObject "\\jmath"}
  2995.  
  2996. #--------------------------------------------------------------------------
  2997. # Grouping:
  2998. #--------------------------------------------------------------------------
  2999.  
  3000. proc underline {} {
  3001.     checkMathMode "underline" 1
  3002.     if {[wrapObject "\\underline{" "}Ñ"]} then {
  3003.         message "selection underlined"
  3004.     } else {
  3005.         message "enter text"
  3006.     }
  3007. }
  3008. proc overline {} {
  3009.     checkMathMode "overline" 1
  3010.     if {[wrapObject "\\overline{" "}Ñ"]} then {
  3011.         message "selection overlined"
  3012.     } else {
  3013.         message "enter text"
  3014.     }
  3015. }
  3016. proc underbrace {} {
  3017.     checkMathMode "underbrace" 1
  3018.     if {[wrapObject "\\underbrace{" "}Ñ"]} then {
  3019.         message "selection underbraced"
  3020.     } else {
  3021.         message "enter text"
  3022.     }
  3023. }
  3024. proc overbrace {} {
  3025.     checkMathMode "overbrace" 1
  3026.     if {[wrapObject "\\overbrace{" "}Ñ"]} then {
  3027.         message "selection overbraced"
  3028.     } else {
  3029.         message "enter text"
  3030.     }
  3031. }
  3032. proc stackrel {} {
  3033.     checkMathMode "stackrel" 1
  3034.     set currentPos [getPos]
  3035.     if {[insertObject "\\stackrel{Ñ}{Ñ}Ñ"]} then {
  3036.         goto $currentPos
  3037.         nextTabStop
  3038.         message "1st arg scriptstyle"
  3039.     }
  3040. }
  3041.  
  3042. #--------------------------------------------------------------------------
  3043. # Spacing:
  3044. #--------------------------------------------------------------------------
  3045.  
  3046. proc negThin {} {checkMathMode "negThin" 1; insertObject "\\!"}
  3047. proc thin {} {checkMathMode "thin" 1; insertObject "\\,"}
  3048. proc medium {} {checkMathMode "medium" 1; insertObject "\\:"}
  3049. proc thick {} {checkMathMode "thick" 1; insertObject "\\;"}
  3050. proc quad {} {checkMathMode "quad" 1; insertObject "\\quad"}
  3051. proc qquad {} {checkMathMode "qquad" 1; insertObject "\\qquad"}
  3052. proc hspace {} {
  3053.     checkMathMode "hspace" 1
  3054.     if {[wrapObject "\\hspace{" "}Ñ"]} then {
  3055.         message "spacing set"
  3056.     } else {
  3057.         message "enter the desired horizontal spacing"
  3058.     }
  3059. }
  3060. proc vspace {} {
  3061.     checkMathMode "vspace" 1
  3062.     if {[wrapObject "\\vspace{" "}Ñ"]} then {
  3063.         message "spacing set"
  3064.     } else {
  3065.         message "enter the desired horizontal spacing"
  3066.     }
  3067. }
  3068. proc hfill {} {checkMathMode "hfill" 1; insertObject "\\hfill"}
  3069. proc vfill {} {checkMathMode "vfill" 1; insertObject "\\vfill"}
  3070. proc smallskip {} {checkMathMode "smallskip" 1; insertObject "\\smallskip"}
  3071. proc medskip {} {checkMathMode "medskip" 1; insertObject "\\medskip"}
  3072. proc bigskip {} {checkMathMode "bigskip" 1; insertObject "\\bigskip"}
  3073.  
  3074.